@intentius/chant-lexicon-aws 0.124.30 → 0.124.32

package/dist/codegen/extensions.js

@@ -0,0 +1,139 @@
+/**
+ * cfn-lint extension constraints — cross-property validation rules.
+ *
+ * Downloads extension schemas from the same cfn-lint tarball and parses
+ * them into typed constraint objects for inclusion in lexicon JSON.
+ */
+import { readFileSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { fetchAndExtractTar } from "@intentius/chant/codegen/fetch";
+import { typeNameToPatchDir } from "./patches.js";
+import { cfnLintTarballUrl } from "./versions.js";
+const CFN_LINT_TARBALL_URL = cfnLintTarballUrl();
+const EXTENSIONS_DEST_DIR = join(homedir(), ".chant", "cfn-lint-extensions");
+const EXTENSIONS_TAR_PREFIX = "src/cfnlint/data/schemas/extensions/";
+/**
+ * Fetch cfn-lint extensions from GitHub tarball and extract to cache.
+ */
+export async function fetchCfnLintExtensions(force = false) {
+    return fetchAndExtractTar({ url: CFN_LINT_TARBALL_URL, destDir: EXTENSIONS_DEST_DIR }, EXTENSIONS_TAR_PREFIX, force);
+}
+/**
+ * Load extension schemas for known resource types.
+ * Returns a map of CFN type name → extension constraints.
+ */
+export function loadExtensionSchemas(extensionsDir, knownTypes) {
+    // Build reverse map: directory name → CFN type name
+    const dirToType = new Map();
+    for (const typeName of knownTypes) {
+        dirToType.set(typeNameToPatchDir(typeName), typeName);
+    }
+    const result = new Map();
+    let entries;
+    try {
+        entries = readdirSync(extensionsDir);
+    }
+    catch {
+        return result;
+    }
+    for (const entry of entries) {
+        const fullPath = join(extensionsDir, entry);
+        try {
+            if (!statSync(fullPath).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const cfnType = dirToType.get(entry);
+        if (!cfnType)
+            continue;
+        const constraints = loadDirectoryConstraints(fullPath);
+        if (constraints.length > 0) {
+            result.set(cfnType, constraints);
+        }
+    }
+    return result;
+}
+/**
+ * Load all constraints from JSON files in a directory.
+ */
+function loadDirectoryConstraints(dir) {
+    const constraints = [];
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return constraints;
+    }
+    for (const entry of entries) {
+        if (!entry.endsWith(".json"))
+            continue;
+        let data;
+        try {
+            data = readFileSync(join(dir, entry), "utf-8");
+        }
+        catch {
+            continue;
+        }
+        try {
+            const parsed = parseExtensionSchema(entry, data);
+            constraints.push(...parsed);
+        }
+        catch {
+            // Skip files that don't parse as constraints
+        }
+    }
+    return constraints;
+}
+/**
+ * Parse a single extension JSON Schema file into constraint objects.
+ */
+function parseExtensionSchema(fileName, data) {
+    const raw = JSON.parse(data);
+    const name = fileName.replace(/\.json$/, "");
+    const constraints = [];
+    // Check for allOf containing multiple constraints
+    if ("allOf" in raw && Array.isArray(raw.allOf)) {
+        for (let i = 0; i < raw.allOf.length; i++) {
+            const item = raw.allOf[i];
+            try {
+                const c = classifySingleConstraint(`${name}_${i}`, item);
+                constraints.push(c);
+            }
+            catch {
+                // Skip unrecognized items
+            }
+        }
+        if (constraints.length > 0)
+            return constraints;
+    }
+    // Single top-level constraint
+    const c = classifySingleConstraint(name, raw);
+    return [c];
+}
+/**
+ * Classify a single JSON Schema document into an ExtensionConstraint.
+ */
+function classifySingleConstraint(name, raw) {
+    const hasIf = "if" in raw;
+    const hasThen = "then" in raw;
+    const hasDependentExcluded = "dependentExcluded" in raw;
+    const hasRequiredOr = "requiredOr" in raw;
+    const hasRequiredXor = "requiredXor" in raw;
+    if (hasRequiredXor) {
+        return { name, type: "required_xor", requirement: raw.requiredXor };
+    }
+    if (hasRequiredOr) {
+        return { name, type: "required_or", requirement: raw.requiredOr };
+    }
+    if (hasDependentExcluded) {
+        return { name, type: "dependent_excluded", requirement: raw.dependentExcluded };
+    }
+    if (hasIf && hasThen) {
+        return { name, type: "if_then", condition: raw.if, requirement: raw.then };
+    }
+    throw new Error(`unrecognized constraint pattern in ${name}`);
+}

package/dist/codegen/fallback.js

@@ -0,0 +1,32 @@
+/**
+ * Fallback resource definitions for priority types missing from the schema zip.
+ * Acts as a safety net — if the schema zip already contains the resource,
+ * the fallback is not used.
+ */
+export function fallbackResources() {
+    return [fallbackLogGroup()];
+}
+function fallbackLogGroup() {
+    return {
+        resource: {
+            typeName: "AWS::Logs::LogGroup",
+            properties: [
+                { name: "LogGroupName", tsType: "string", required: false, constraints: {} },
+                { name: "RetentionInDays", tsType: "number", required: false, constraints: {} },
+                { name: "KmsKeyId", tsType: "string", required: false, constraints: {} },
+                { name: "DataProtectionPolicy", tsType: "any", required: false, constraints: {} },
+                { name: "Tags", tsType: "Tag[]", required: false, constraints: {} },
+                { name: "LogGroupClass", tsType: "string", required: false, constraints: {} },
+            ],
+            attributes: [{ name: "Arn", tsType: "string" }],
+            createOnly: [],
+            writeOnly: [],
+            primaryIdentifier: [],
+            deprecatedProperties: [],
+            inferredDeprecations: [],
+            conditionalCreateOnly: [],
+        },
+        propertyTypes: [],
+        enums: [],
+    };
+}

package/dist/codegen/generate-cli.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env tsx
+/**
+ * Thin entry point for `npm run generate` in lexicon-aws.
+ */
+import { generate, writeGeneratedFiles } from "./generate.js";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+const result = await generate({ verbose: true });
+// src/codegen/generate-cli.ts → dirname x3 → package root
+const pkgDir = dirname(dirname(dirname(fileURLToPath(import.meta.url))));
+writeGeneratedFiles(result, pkgDir);
+console.error(`Generated ${result.resources} resources, ${result.properties} property types, ${result.enums} enums`);
+if (result.warnings.length > 0) {
+    console.error(`${result.warnings.length} warnings`);
+}

package/dist/codegen/generate-lexicon.js

@@ -0,0 +1,70 @@
+/**
+ * Lexicon JSON generator — produces lexicon-aws.json with metadata for all resources.
+ *
+ * Output is a Record<string, LexiconEntry> keyed by generated class name.
+ */
+import { cfnShortName } from "../spec/parse.js";
+import { buildRegistry, serializeRegistry, } from "@intentius/chant/codegen/generate-registry";
+/**
+ * Generate the lexicon-aws.json content.
+ */
+export function generateLexiconJSON(results, naming, constraints, runtimeDeprecations) {
+    // Adapt SchemaParseResult[] to RegistryResource[]
+    const registryResources = results.map((r) => ({
+        typeName: r.resource.typeName,
+        attributes: r.resource.attributes,
+        properties: r.resource.properties,
+        propertyTypes: r.propertyTypes,
+    }));
+    const entries = buildRegistry(registryResources, naming, {
+        shortName: cfnShortName,
+        buildEntry: (resource, _tsName, attrs, propConstraints) => {
+            const cfnType = resource.typeName;
+            const r = results.find((res) => res.resource.typeName === cfnType);
+            // Runtime deprecation data for Lambda resources with Runtime property
+            let runtimeDepr;
+            if (runtimeDeprecations && r.resource.properties.some((p) => p.name === "Runtime")) {
+                runtimeDepr = runtimeDeprecations;
+            }
+            return {
+                resourceType: cfnType,
+                kind: "resource",
+                lexicon: "aws",
+                ...(attrs && { attrs }),
+                ...(constraints.has(cfnType) && { constraints: constraints.get(cfnType) }),
+                ...(propConstraints && { propertyConstraints: propConstraints }),
+                ...(r.resource.createOnly.length > 0 && { createOnly: r.resource.createOnly }),
+                ...(r.resource.writeOnly.length > 0 && { writeOnly: r.resource.writeOnly }),
+                ...(r.resource.primaryIdentifier.length > 0 && { primaryIdentifier: r.resource.primaryIdentifier }),
+                ...(r.resource.deprecatedProperties?.length && { deprecatedProperties: r.resource.deprecatedProperties }),
+                ...(r.resource.inferredDeprecations?.length && { inferredDeprecations: r.resource.inferredDeprecations }),
+                ...(r.resource.conditionalCreateOnly?.length && { conditionalCreateOnly: r.resource.conditionalCreateOnly }),
+                ...(r.resource.replacementStrategy && { replacementStrategy: r.resource.replacementStrategy }),
+                ...(r.resource.tagging && { tagging: r.resource.tagging }),
+                ...(runtimeDepr && { runtimeDeprecations: runtimeDepr }),
+            };
+        },
+        buildPropertyEntry: (resourceType, propertyType) => ({
+            resourceType: `${resourceType}.${propertyType}`,
+            kind: "property",
+            lexicon: "aws",
+        }),
+    });
+    return serializeRegistry(entries);
+}
+/**
+ * Lambda runtime deprecation fallback data.
+ */
+export function lambdaRuntimeDeprecations() {
+    return {
+        "nodejs14.x": "deprecated",
+        "nodejs16.x": "deprecated",
+        "nodejs18.x": "approaching_eol",
+        "python3.7": "deprecated",
+        "python3.8": "deprecated",
+        "python3.9": "approaching_eol",
+        "dotnet6": "deprecated",
+        "java8": "deprecated",
+        "ruby2.7": "deprecated",
+    };
+}

package/dist/codegen/generate-typescript.js

@@ -0,0 +1,226 @@
+/**
+ * TypeScript declaration file generator — produces index.d.ts with all resource classes.
+ *
+ * Output includes:
+ * - Resource classes with typed constructors and readonly attributes
+ * - Property type classes
+ * - Enum union types
+ * - Static content (intrinsics, pseudo-parameters, common interfaces)
+ */
+import { cfnShortName } from "../spec/parse.js";
+import { propertyTypeName, extractDefName } from "./naming.js";
+import { writeResourceClass, writePropertyClass, writeEnumType, } from "@intentius/chant/codegen/generate-typescript";
+/**
+ * Generate the complete .d.ts file content.
+ */
+export function generateTypeScriptDeclarations(results, naming) {
+    const lines = [];
+    lines.push("// Code generated by chant aws generate. DO NOT EDIT generated sections.");
+    const resources = [];
+    const properties = [];
+    const enums = [];
+    for (const r of results) {
+        const cfnType = r.resource.typeName;
+        const tsName = naming.resolve(cfnType);
+        if (!tsName)
+            continue;
+        // Build remap from parser property type names to resolved names
+        const shortName = cfnShortName(cfnType);
+        const remap = new Map();
+        for (const pt of r.propertyTypes) {
+            const defName = extractDefName(pt.name, shortName);
+            remap.set(pt.name, propertyTypeName(tsName, defName));
+        }
+        for (const e of r.enums) {
+            const defName = extractDefName(e.name, shortName);
+            remap.set(e.name, propertyTypeName(tsName, defName));
+        }
+        // Map ParsedProperty/ParsedAttribute → DtsProperty/DtsAttribute
+        const dtsProps = r.resource.properties.map((p) => ({
+            name: p.name,
+            type: isPolicyDocumentProperty(p.name, p.tsType) ? "PolicyDocument" : p.tsType,
+            required: p.required,
+            description: p.description,
+        }));
+        const dtsAttrs = r.resource.attributes.map((a) => ({
+            name: a.name.replace(/\./g, "_").replace(/\*/g, "Item"), // Subscribers.*.Status → Subscribers_Item_Status
+            type: a.tsType,
+        }));
+        resources.push({ tsName, properties: dtsProps, attributes: dtsAttrs, remap });
+        // Alias entries as separate resource entries
+        for (const alias of naming.aliases(cfnType)) {
+            resources.push({ tsName: alias, properties: dtsProps, attributes: dtsAttrs, remap });
+        }
+        const ptAliases = naming.propertyTypeAliases(cfnType);
+        for (const pt of r.propertyTypes) {
+            const defName = extractDefName(pt.name, shortName);
+            const ptName = propertyTypeName(tsName, defName);
+            const ptProps = pt.properties.map((p) => ({
+                name: p.name,
+                type: isPolicyDocumentProperty(p.name, p.tsType) ? "PolicyDocument" : p.tsType,
+                required: p.required,
+                description: p.description,
+            }));
+            properties.push({ tsName: ptName, properties: ptProps, remap });
+            // Alias class declaration for globally unique property types
+            if (ptAliases) {
+                const aliasName = ptAliases.get(defName);
+                if (aliasName) {
+                    properties.push({ tsName: aliasName, properties: ptProps, remap });
+                }
+            }
+        }
+        for (const e of r.enums) {
+            const defName = extractDefName(e.name, shortName);
+            const eName = propertyTypeName(tsName, defName);
+            enums.push({ tsName: eName, values: e.values });
+        }
+    }
+    // Sort all entries alphabetically
+    resources.sort((a, b) => a.tsName.localeCompare(b.tsName));
+    properties.sort((a, b) => a.tsName.localeCompare(b.tsName));
+    enums.sort((a, b) => a.tsName.localeCompare(b.tsName));
+    // Section 1: Resource classes
+    lines.push("");
+    lines.push("// --- Resource classes ---");
+    for (const re of resources) {
+        writeResourceClass(lines, re.tsName, re.properties, re.attributes, re.remap, "CFResourceAttributes");
+    }
+    // Section 2: Property classes
+    lines.push("");
+    lines.push("// --- Property classes ---");
+    for (const pe of properties) {
+        writePropertyClass(lines, pe.tsName, pe.properties, pe.remap);
+    }
+    // Section 3: Enum types
+    if (enums.length > 0) {
+        lines.push("");
+        lines.push("// --- Enum types ---");
+        for (const ee of enums) {
+            writeEnumType(lines, ee.tsName, ee.values);
+        }
+    }
+    // Section 4: Static content
+    lines.push("");
+    lines.push(staticTypeScript());
+    lines.push("");
+    return lines.join("\n");
+}
+// --- PolicyDocument type overrides ---
+const policyDocumentPropertyNames = new Set([
+    "assumerolepolicydocument",
+    "policydocument",
+    "permissionspolicydocument",
+    "resourcepolicydocument",
+]);
+function isPolicyDocumentProperty(name, tsType) {
+    return tsType === "Record<string, any>" &&
+        policyDocumentPropertyNames.has(name.toLowerCase());
+}
+// --- Static content ---
+function staticTypeScript() {
+    const lines = [];
+    // Intrinsic functions
+    lines.push("// --- Intrinsic functions ---");
+    lines.push("");
+    const intrinsics = [
+        ["And", "(conditions: unknown[]): any"],
+        ["Base64", "(value: unknown): any"],
+        ["Cidr", "(ipBlock: unknown, count: unknown, cidrBits?: unknown): any"],
+        ["And", "(...conditions: unknown[]): any"],
+        ["Equals", "(a: unknown, b: unknown): any"],
+        ["FindInMap", "(mapName: string, firstKey: unknown, secondKey: unknown): any"],
+        ["GetAtt", "(logicalName: string, attribute: string): any"],
+        ["GetAZs", "(region?: string): any"],
+        ["If", "(condition: string | Declarable, valueIfTrue: unknown, valueIfFalse: unknown): any"],
+        ["ImportValue", "(sharedValue: unknown): any"],
+        ["Join", "(delimiter: string, values: unknown[]): any"],
+        ["Not", "(condition: unknown): any"],
+        ["Or", "(conditions: unknown[]): any"],
+        ["Ref", "(logicalName: string): any"],
+        ["Select", "(index: number, values: unknown[]): any"],
+        ["Split", "(delimiter: string, source: unknown): any"],
+        ["Sub", "(parts: TemplateStringsArray, ...values: unknown[]): any"],
+        ["Transform", "(name: string, parameters: Record<string, unknown>): any"],
+    ];
+    intrinsics.sort((a, b) => a[0].localeCompare(b[0]));
+    for (const [name, sig] of intrinsics) {
+        lines.push(`export declare function ${name}${sig};`);
+    }
+    // Pseudo-parameters
+    lines.push("");
+    lines.push("// --- Pseudo-parameters ---");
+    lines.push("");
+    lines.push("export declare const AWS: {");
+    const pseudoParams = [
+        "AccountId",
+        "NotificationARNs",
+        "NoValue",
+        "Partition",
+        "Region",
+        "StackId",
+        "StackName",
+        "URLSuffix",
+    ];
+    for (const p of pseudoParams) {
+        lines.push(`  readonly ${p}: any;`);
+    }
+    lines.push("};");
+    // Type interfaces
+    lines.push("");
+    lines.push("// --- Type interfaces ---");
+    lines.push("");
+    lines.push("export interface Declarable {");
+    lines.push("  readonly entityType: string;");
+    lines.push("}");
+    lines.push("");
+    lines.push("export interface CFResourceAttributes {");
+    lines.push("  DependsOn?: Declarable | Declarable[] | string | string[];");
+    lines.push("  Condition?: string | Declarable;");
+    lines.push('  DeletionPolicy?: "Delete" | "Retain" | "RetainExceptOnCreate" | "Snapshot";');
+    lines.push('  UpdateReplacePolicy?: "Delete" | "Retain" | "Snapshot";');
+    lines.push("  UpdatePolicy?: {");
+    lines.push("    AutoScalingReplacingUpdate?: { WillReplace?: boolean };");
+    lines.push("    AutoScalingRollingUpdate?: {");
+    lines.push("      MaxBatchSize?: number;");
+    lines.push("      MinInstancesInService?: number;");
+    lines.push("      PauseTime?: string;");
+    lines.push("      WaitOnResourceSignals?: boolean;");
+    lines.push("    };");
+    lines.push("  };");
+    lines.push("  CreationPolicy?: {");
+    lines.push("    ResourceSignal?: { Count?: number; Timeout?: string };");
+    lines.push("  };");
+    lines.push("  Metadata?: Record<string, unknown>;");
+    lines.push("}");
+    lines.push("");
+    lines.push("export interface PolicyDocument {");
+    lines.push('  Version?: "2012-10-17" | "2008-10-17";');
+    lines.push("  Id?: string;");
+    lines.push("  Statement: IamPolicyStatement | IamPolicyStatement[];");
+    lines.push("}");
+    lines.push("");
+    lines.push("export interface IamPolicyStatement {");
+    lines.push("  Sid?: string;");
+    lines.push('  Effect: "Allow" | "Deny";');
+    lines.push("  Principal?: IamPolicyPrincipal;");
+    lines.push("  NotPrincipal?: IamPolicyPrincipal;");
+    lines.push("  Action?: string | string[];");
+    lines.push("  NotAction?: string | string[];");
+    lines.push("  Resource?: string | string[];");
+    lines.push("  NotResource?: string | string[];");
+    lines.push("  Condition?: Record<string, Record<string, string | string[]>>;");
+    lines.push("}");
+    lines.push("");
+    lines.push('export type IamPolicyPrincipal = "*" | {');
+    lines.push("  AWS?: string | string[];");
+    lines.push("  Service?: string | string[];");
+    lines.push("  Federated?: string | string[];");
+    lines.push("};");
+    lines.push("");
+    lines.push("export interface Tag {");
+    lines.push("  key: string;");
+    lines.push("  value: string;");
+    lines.push("}");
+    return lines.join("\n");
+}

package/dist/codegen/generate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/codegen/generate.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,cAAc,EAGpB,MAAM,mCAAmC,CAAC;AAmC3C,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,CAAC;AA0IhD;;GAEG;AACH,wBAAsB,QAAQ,CAAC,IAAI,GAAE,eAAoB,GAAG,OAAO,CAAC,cAAc,CAAC,CAkBlF;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAgBjF"}
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/codegen/generate.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,cAAc,EAGpB,MAAM,mCAAmC,CAAC;AAmC3C,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,CAAC;AAmJhD;;GAEG;AACH,wBAAsB,QAAQ,CAAC,IAAI,GAAE,eAAoB,GAAG,OAAO,CAAC,cAAc,CAAC,CAkBlF;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAgBjF"}