@intentius/chant-lexicon-azure 0.124.31 → 0.124.33

package/dist/codegen/generate.js

@@ -0,0 +1,106 @@
+/**
+ * Azure ARM generation pipeline — uses core generatePipeline
+ * with Azure-specific fetch, parse, naming, and generation callbacks.
+ */
+import { generatePipeline, writeGeneratedArtifacts, } from "@intentius/chant/codegen/generate";
+import { fetchArmSchemas } from "../spec/fetch.js";
+import { parseArmSchema, armShortName } from "../spec/parse.js";
+import { NamingStrategy, propertyTypeName, extractDefName } from "./naming.js";
+import { generateLexiconJSON } from "./generate-lexicon.js";
+import { generateTypeScriptDeclarations } from "./generate-typescript.js";
+import { generateRuntimeIndex as coreGenerateRuntimeIndex, } from "@intentius/chant/codegen/generate-runtime-index";
+const azurePipelineConfig = {
+    fetchSchemas: async (opts) => {
+        return fetchArmSchemas(opts.force);
+    },
+    parseSchema: (_typeName, data) => {
+        const result = parseArmSchema(data);
+        if (!result.resource.typeName)
+            return null;
+        return result;
+    },
+    createNaming: (results) => new NamingStrategy(results),
+    generateRegistry: (results, naming) => {
+        return generateLexiconJSON(results, naming);
+    },
+    generateTypes: (results, naming) => {
+        return generateTypeScriptDeclarations(results, naming);
+    },
+    generateRuntimeIndex: (results, naming) => {
+        return generateRuntimeIndex(results, naming);
+    },
+};
+/**
+ * Run the full Azure generation pipeline.
+ */
+export async function generate(opts = {}) {
+    return generatePipeline(azurePipelineConfig, opts);
+}
+/**
+ * Write generated artifacts to disk.
+ */
+export function writeGeneratedFiles(result, baseDir) {
+    writeGeneratedArtifacts({
+        baseDir,
+        files: {
+            "lexicon-azure.json": result.lexiconJSON,
+            "index.d.ts": result.typesDTS,
+            "index.ts": result.indexTS,
+            "runtime.ts": [
+                "/**",
+                " * Runtime factory constructors — re-exported from core.",
+                " */",
+                'export { createResource, createProperty } from "@intentius/chant/runtime";',
+                "",
+            ].join("\n"),
+        },
+    });
+}
+/**
+ * Generate the runtime index.ts with factory constructor exports.
+ */
+function generateRuntimeIndex(results, naming) {
+    const resourceEntries = [];
+    const propertyEntries = [];
+    for (const r of results) {
+        const armType = r.resource.typeName;
+        const tsName = naming.resolve(armType);
+        if (!tsName)
+            continue;
+        // Build attrs map
+        const attrs = {};
+        for (const a of r.resource.attributes) {
+            attrs[a.name.replace(/\./g, "_")] = a.name;
+        }
+        resourceEntries.push({ tsName, resourceType: armType, attrs });
+        for (const alias of naming.aliases(armType)) {
+            resourceEntries.push({ tsName: alias, resourceType: armType, attrs });
+        }
+        // Property types
+        const shortName = armShortName(armType);
+        const ptAliases = naming.propertyTypeAliases(armType);
+        for (const pt of r.propertyTypes) {
+            const defName = extractDefName(pt.name, shortName);
+            const ptName = propertyTypeName(tsName, defName);
+            const ptArmType = `${armType}.${pt.specType}`;
+            propertyEntries.push({ tsName: ptName, resourceType: ptArmType });
+            if (ptAliases) {
+                const aliasName = ptAliases.get(defName);
+                if (aliasName) {
+                    propertyEntries.push({ tsName: aliasName, resourceType: ptArmType });
+                }
+            }
+        }
+    }
+    return coreGenerateRuntimeIndex(resourceEntries, propertyEntries, {
+        lexiconName: "azure",
+        intrinsicReExports: {
+            names: ["ResourceId", "Reference", "Concat", "ResourceGroup", "Subscription", "UniqueString", "Format", "If", "ListKeys"],
+            from: "../intrinsics",
+        },
+        pseudoReExports: {
+            names: ["Azure", "ResourceGroupName", "ResourceGroupLocation", "ResourceGroupId", "SubscriptionId", "TenantId", "DeploymentName"],
+            from: "../pseudo",
+        },
+    });
+}

package/dist/codegen/naming.js

@@ -0,0 +1,139 @@
+/**
+ * Azure-specific naming configuration for the core NamingStrategy.
+ *
+ * The algorithm lives in core; only the data tables and helper functions
+ * for extracting names from Azure resource types are defined here.
+ */
+import { NamingStrategy as CoreNamingStrategy, } from "@intentius/chant/codegen/naming";
+export { propertyTypeName, extractDefName } from "@intentius/chant/codegen/naming";
+import { armShortName, armServiceName } from "../spec/parse.js";
+/**
+ * Fixed TypeScript class names for core Azure resources.
+ */
+const priorityNames = {
+    "Microsoft.Storage/storageAccounts": "StorageAccount",
+    "Microsoft.Compute/virtualMachines": "VirtualMachine",
+    "Microsoft.Network/virtualNetworks": "VirtualNetwork",
+    "Microsoft.Network/networkSecurityGroups": "NetworkSecurityGroup",
+    "Microsoft.Network/publicIPAddresses": "PublicIPAddress",
+    "Microsoft.Network/networkInterfaces": "NetworkInterface",
+    "Microsoft.Network/loadBalancers": "LoadBalancer",
+    "Microsoft.Network/routeTables": "RouteTable",
+    "Microsoft.Web/serverfarms": "AppServicePlan",
+    "Microsoft.Web/sites": "WebApp",
+    "Microsoft.Sql/servers": "SqlServer",
+    "Microsoft.Sql/servers_databases": "SqlDatabase",
+    "Microsoft.Sql/servers_firewallRules": "SqlFirewallRule",
+    "Microsoft.KeyVault/vaults": "KeyVault",
+    "Microsoft.ContainerService/managedClusters": "ManagedCluster",
+    "Microsoft.ContainerRegistry/registries": "ContainerRegistry",
+    "Microsoft.DocumentDB/databaseAccounts": "CosmosDbAccount",
+    "Microsoft.Compute/disks": "ManagedDisk",
+    "Microsoft.Compute/availabilitySets": "AvailabilitySet",
+    "Microsoft.Network/applicationGateways": "ApplicationGateway",
+    "Microsoft.Network/privateDnsZones": "PrivateDnsZone",
+    "Microsoft.Network/dnsZones": "DnsZone",
+    "Microsoft.ManagedIdentity/userAssignedIdentities": "ManagedIdentity",
+    "Microsoft.Authorization/roleAssignments": "RoleAssignment",
+    "Microsoft.Authorization/roleDefinitions": "RoleDefinition",
+    "Microsoft.Authorization/policyDefinitions": "PolicyDefinition",
+    "Microsoft.Authorization/policyAssignments": "PolicyAssignment",
+    "Microsoft.Authorization/policySetDefinitions": "PolicySetDefinition",
+    "Microsoft.Authorization/policyExemptions": "PolicyExemption",
+    "Microsoft.Management/managementGroups": "ManagementGroup",
+    "Microsoft.Management/managementGroups_subscriptions": "ManagementGroupSubscription",
+    "Microsoft.Subscription/aliases": "SubscriptionAlias",
+    "Microsoft.Insights/diagnosticSettings": "DiagnosticSetting",
+    "Microsoft.Insights/components": "AppInsights",
+    "Microsoft.OperationalInsights/workspaces": "LogAnalyticsWorkspace",
+    "Microsoft.EventHub/namespaces": "EventHubNamespace",
+    "Microsoft.ServiceBus/namespaces": "ServiceBusNamespace",
+    "Microsoft.Cache/redis": "RedisCache",
+    "Microsoft.Cdn/profiles": "CdnProfile",
+    "Microsoft.SignalRService/signalR": "SignalR",
+    "Microsoft.Storage/storageAccounts_blobServices_containers": "BlobContainer",
+    "Microsoft.Network/virtualNetworks_subnets": "Subnet",
+    "Microsoft.Network/trafficmanagerprofiles": "TrafficManagerProfile",
+    "Microsoft.Compute/virtualMachineScaleSets": "VirtualMachineScaleSet",
+    "Microsoft.Resources/deployments": "Deployment",
+};
+/**
+ * Additional TypeScript names beyond the primary priority name.
+ */
+const priorityAliases = {
+    "Microsoft.Web/sites": ["AppService"],
+    "Microsoft.ContainerService/managedClusters": ["AksCluster"],
+    "Microsoft.DocumentDB/databaseAccounts": ["CosmosDb"],
+    "Microsoft.ManagedIdentity/userAssignedIdentities": ["UserAssignedIdentity"],
+};
+/**
+ * Property type aliases for backward compatibility.
+ */
+const priorityPropertyAliases = {
+    "Microsoft.Storage/storageAccounts": {
+        Encryption: "StorageEncryption",
+        NetworkRuleSet: "StorageNetworkRules",
+        Sku: "Sku",
+    },
+    "Microsoft.Compute/virtualMachines": {
+        HardwareProfile: "HardwareProfile",
+        StorageProfile: "StorageProfile",
+        OSProfile: "OsProfile",
+        NetworkProfile: "NetworkProfile",
+        OSDisk: "OsDisk",
+        ImageReference: "ImageReference",
+    },
+    "Microsoft.Compute/virtualMachineScaleSets": {
+        VirtualMachineScaleSetIdentity: "Identity",
+    },
+    "Microsoft.Network/networkSecurityGroups": {
+        CommonSecurityRule: "SecurityRule",
+    },
+    "Microsoft.Network/virtualNetworks_subnets": {
+        CommonSubnetPropertiesFormat: "SubnetProperties",
+    },
+    "Microsoft.Network/networkInterfaces": {
+        CommonNetworkInterfaceIPConfiguration: "IpConfiguration",
+    },
+    "Microsoft.Sql/servers_databases": {
+        Sku: "SqlSku",
+    },
+    "Microsoft.Web/sites": {
+        SiteConfig: "SiteConfig",
+    },
+};
+/**
+ * Service name abbreviations for collision-resolved names.
+ */
+const serviceAbbreviations = {
+    ContainerService: "Aks",
+    ContainerRegistry: "Acr",
+    OperationalInsights: "Oi",
+    ManagedIdentity: "Mi",
+    Authorization: "Auth",
+    DocumentDB: "Cosmos",
+    SignalRService: "Sr",
+    ServiceBus: "Sb",
+    EventHub: "Eh",
+    Insights: "Ai",
+};
+const azureNamingConfig = {
+    priorityNames,
+    priorityAliases,
+    priorityPropertyAliases,
+    serviceAbbreviations,
+    shortName: armShortName,
+    serviceName: armServiceName,
+};
+/**
+ * Azure-specific NamingStrategy — wraps the core algorithm with Azure data tables.
+ */
+export class NamingStrategy extends CoreNamingStrategy {
+    constructor(results) {
+        const inputs = results.map((r) => ({
+            typeName: r.resource.typeName,
+            propertyTypes: r.propertyTypes,
+        }));
+        super(inputs, azureNamingConfig);
+    }
+}

package/dist/codegen/package.js

@@ -0,0 +1,64 @@
+/**
+ * Azure lexicon packaging — delegates to core packagePipeline
+ * with Azure-specific manifest building and skill collection.
+ */
+import { readFileSync } from "fs";
+import { azurePlugin } from "../plugin.js";
+import { dirname } from "path";
+import { moduleSourceDir } from "@intentius/chant/module-source";
+import { packagePipeline, collectSkills, } from "@intentius/chant/codegen/package";
+import { generate } from "./generate.js";
+const pkgDir = dirname(moduleSourceDir(import.meta.url));
+/**
+ * Map intrinsic name to its ARM output key.
+ */
+function intrinsicOutputKey(name) {
+    return name;
+}
+/**
+ * Package the Azure lexicon into a distributable BundleSpec.
+ */
+export async function packageLexicon(opts = {}) {
+    const pkgJson = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf-8"));
+    return packagePipeline({
+        generate: (genOpts) => generate({ verbose: genOpts.verbose, force: genOpts.force }),
+        buildManifest: (_genResult) => {
+            // Lazy-import to avoid circular dependency
+            // Trust the plugin's own `isTag` registration (chant #1067) instead
+            // of hardcoding `false` for every entry regardless of what
+            // ../plugin.ts declares — see aws's codegen/package.ts for the bug
+            // this pattern produced (#1039) when the two sources disagree.
+            const intrinsics = (azurePlugin.intrinsics?.() ?? []).map((i) => ({
+                name: i.name,
+                description: i.description,
+                outputKey: intrinsicOutputKey(i.name),
+                isTag: i.isTag,
+                // chant #1044 — carried through verbatim for the same reason as
+                // `isTag`: the packaged manifest is what a consumer reads to
+                // learn which intrinsics fold, so recomputing it here would be a
+                // second source of truth able to drift from ../plugin.ts.
+                foldsAsCall: i.foldsAsCall,
+            }));
+            const pseudoParams = azurePlugin.pseudoParameters?.() ?? [];
+            const pseudoParameters = {};
+            for (const p of pseudoParams) {
+                const shortName = p.split(".").pop();
+                pseudoParameters[shortName] = p;
+            }
+            return {
+                name: "azure",
+                version: pkgJson.version ?? "0.0.0",
+                chantVersion: ">=0.1.0",
+                namespace: "Azure",
+                intrinsics,
+                pseudoParameters,
+            };
+        },
+        srcDir: pkgDir,
+        collectSkills: () => {
+            const skillDefs = azurePlugin.skills?.() ?? [];
+            return collectSkills(skillDefs);
+        },
+        version: pkgJson.version ?? "0.0.0",
+    }, opts);
+}

package/dist/composites/aks-cluster.js

@@ -0,0 +1,68 @@
+/**
+ * AksCluster composite — Azure Kubernetes Service cluster.
+ *
+ * A higher-level construct for deploying an AKS cluster with
+ * managed identity, RBAC, and a default node pool.
+ */
+import { Composite, mergeDefaults } from "@intentius/chant";
+import { AksCluster as AksClusterResource } from "../generated/index.js";
+/**
+ * Create an AksCluster composite — returns an AKS managed cluster
+ * with production defaults.
+ *
+ * @example
+ * ```ts
+ * import { AksCluster } from "@intentius/chant-lexicon-azure";
+ *
+ * const { cluster } = AksCluster({
+ *   name: "my-aks",
+ *   nodeCount: 5,
+ *   vmSize: "Standard_D4s_v5",
+ *   kubernetesVersion: "1.29",
+ * });
+ *
+ * export { cluster };
+ * ```
+ */
+export const AksCluster = Composite((props) => {
+    const { name, nodeCount = 3, vmSize = "Standard_D2s_v5", kubernetesVersion = "1.28", location = "[resourceGroup().location]", tags = {}, defaults, } = props;
+    const commonTags = {
+        "managed-by": "chant",
+        ...tags,
+    };
+    const dnsPrefix = name;
+    const cluster = new AksClusterResource(mergeDefaults({
+        name,
+        location,
+        tags: commonTags,
+        identity: {
+            type: "SystemAssigned",
+        },
+        kubernetesVersion,
+        dnsPrefix,
+        enableRBAC: true,
+        agentPoolProfiles: [
+            {
+                name: "default",
+                count: nodeCount,
+                vmSize,
+                osType: "Linux",
+                mode: "System",
+                enableAutoScaling: false,
+                type: "VirtualMachineScaleSets",
+            },
+        ],
+        networkProfile: {
+            networkPlugin: "azure",
+            loadBalancerSku: "standard",
+            serviceCidr: "10.0.0.0/16",
+            dnsServiceIP: "10.0.0.10",
+        },
+        addonProfiles: {
+            omsagent: {
+                enabled: false,
+            },
+        },
+    }, defaults?.cluster), { apiVersion: "2023-08-01" });
+    return { cluster };
+}, "AksCluster");

package/dist/composites/app-service.js

@@ -0,0 +1,62 @@
+/**
+ * AppService composite — App Service Plan + Web App.
+ *
+ * A higher-level construct for deploying a Web App on Azure App Service
+ * with a plan and common defaults (HTTPS-only, TLS 1.2, managed identity).
+ */
+import { Composite, mergeDefaults } from "@intentius/chant";
+import { AppServicePlan, AppService as AppServiceResource } from "../generated/index.js";
+/**
+ * Create an AppService composite — returns an App Service Plan and a Web App.
+ *
+ * @example
+ * ```ts
+ * import { AppService } from "@intentius/chant-lexicon-azure";
+ *
+ * const { plan, webApp } = AppService({
+ *   name: "my-web-app",
+ *   sku: "P1v3",
+ *   runtime: "DOTNETCORE|8.0",
+ *   tags: { environment: "staging" },
+ * });
+ *
+ * export { plan, webApp };
+ * ```
+ */
+export const AppService = Composite((props) => {
+    const { name, sku = "B1", runtime = "NODE|18-lts", location = "[resourceGroup().location]", tags = {}, defaults, } = props;
+    const commonTags = {
+        "managed-by": "chant",
+        ...tags,
+    };
+    const planName = `${name}-plan`;
+    const plan = new AppServicePlan(mergeDefaults({
+        name: planName,
+        location,
+        tags: commonTags,
+        sku: {
+            name: sku,
+        },
+        kind: "linux",
+        reserved: true,
+    }, defaults?.plan), { apiVersion: "2022-09-01" });
+    const webApp = new AppServiceResource(mergeDefaults({
+        name,
+        location,
+        tags: commonTags,
+        kind: "app,linux",
+        identity: {
+            type: "SystemAssigned",
+        },
+        serverFarmId: `[resourceId('Microsoft.Web/serverfarms', '${planName}')]`,
+        httpsOnly: true,
+        siteConfig: {
+            linuxFxVersion: runtime,
+            minTlsVersion: "1.2",
+            ftpsState: "Disabled",
+            alwaysOn: true,
+            http20Enabled: true,
+        },
+    }, defaults?.webApp), { apiVersion: "2022-09-01" });
+    return { plan, webApp };
+}, "AppService");

package/dist/composites/application-gateway.js

@@ -0,0 +1,107 @@
+/**
+ * ApplicationGateway composite — Public IP + Application Gateway.
+ *
+ * Creates a Public IP and Application Gateway with WAF_v2 default SKU
+ * and TLS 1.2 policy.
+ */
+import { Composite, mergeDefaults } from "@intentius/chant";
+import { PublicIPAddress, ApplicationGateway as ApplicationGatewayResource, } from "../generated/index.js";
+export const ApplicationGateway = Composite((props) => {
+    const { name, location = "[resourceGroup().location]", subnetId = "[resourceId('Microsoft.Network/virtualNetworks/subnets', 'vnet', 'appgw-subnet')]", sku = "WAF_v2", tags = {}, defaults, } = props;
+    const mergedTags = { "managed-by": "chant", ...tags };
+    const publicIp = new PublicIPAddress(mergeDefaults({
+        name: `${name}-pip`,
+        location,
+        tags: mergedTags,
+        sku: { name: "Standard" },
+        publicIPAllocationMethod: "Static",
+    }, defaults?.publicIp), { apiVersion: "2023-05-01" });
+    const gateway = new ApplicationGatewayResource(mergeDefaults({
+        name,
+        location,
+        tags: mergedTags,
+        sku: {
+            name: sku,
+            tier: sku,
+            capacity: 2,
+        },
+        sslPolicy: {
+            policyType: "Predefined",
+            policyName: "AppGwSslPolicy20220101",
+            minProtocolVersion: "TLSv1_2",
+        },
+        gatewayIPConfigurations: [
+            {
+                name: "appGatewayIpConfig",
+                properties: {
+                    subnet: { id: subnetId },
+                },
+            },
+        ],
+        frontendIPConfigurations: [
+            {
+                name: "appGwPublicFrontendIp",
+                properties: {
+                    publicIPAddress: {
+                        id: `[resourceId('Microsoft.Network/publicIPAddresses', '${name}-pip')]`,
+                    },
+                },
+            },
+        ],
+        frontendPorts: [
+            { name: "port_80", properties: { port: 80 } },
+        ],
+        backendAddressPools: [
+            { name: "defaultBackendPool", properties: {} },
+        ],
+        backendHttpSettingsCollection: [
+            {
+                name: "defaultHttpSettings",
+                properties: {
+                    port: 80,
+                    protocol: "Http",
+                    cookieBasedAffinity: "Disabled",
+                    requestTimeout: 30,
+                },
+            },
+        ],
+        httpListeners: [
+            {
+                name: "defaultListener",
+                properties: {
+                    frontendIPConfiguration: {
+                        id: `[concat(resourceId('Microsoft.Network/applicationGateways', '${name}'), '/frontendIPConfigurations/appGwPublicFrontendIp')]`,
+                    },
+                    frontendPort: {
+                        id: `[concat(resourceId('Microsoft.Network/applicationGateways', '${name}'), '/frontendPorts/port_80')]`,
+                    },
+                    protocol: "Http",
+                },
+            },
+        ],
+        requestRoutingRules: [
+            {
+                name: "defaultRule",
+                properties: {
+                    ruleType: "Basic",
+                    priority: 100,
+                    httpListener: {
+                        id: `[concat(resourceId('Microsoft.Network/applicationGateways', '${name}'), '/httpListeners/defaultListener')]`,
+                    },
+                    backendAddressPool: {
+                        id: `[concat(resourceId('Microsoft.Network/applicationGateways', '${name}'), '/backendAddressPools/defaultBackendPool')]`,
+                    },
+                    backendHttpSettings: {
+                        id: `[concat(resourceId('Microsoft.Network/applicationGateways', '${name}'), '/backendHttpSettingsCollection/defaultHttpSettings')]`,
+                    },
+                },
+            },
+        ],
+    }, defaults?.gateway), {
+        apiVersion: "2023-05-01",
+        DependsOn: [
+            `[resourceId('Microsoft.Network/publicIPAddresses', '${name}-pip')]`,
+        ],
+    });
+    return { publicIp, gateway };
+}, "ApplicationGateway");