@microsoft/terraform-cdk-constructs 0.0.3-pre.10

package/lib/azure-functionapp/lib/functionapplinux.d.ts

@@ -0,0 +1,211 @@
+import { LinuxFunctionAppSiteConfig, LinuxFunctionAppSiteConfigApplicationStack, LinuxFunctionAppAuthSettings, LinuxFunctionAppAuthSettingsV2, LinuxFunctionAppIdentity, LinuxFunctionAppConnectionString } from "@cdktf/provider-azurerm/lib/linux-function-app";
+import { ResourceGroup } from "@cdktf/provider-azurerm/lib/resource-group";
+import { ServicePlan } from "@cdktf/provider-azurerm/lib/service-plan";
+import { StorageAccount } from "@cdktf/provider-azurerm/lib/storage-account";
+import { Construct } from "constructs";
+import { AzureResource } from "../../core-azure/lib";
+/**
+ * Properties for the Azure Linux Function App
+ */
+export interface FunctionAppLinuxProps {
+    /**
+     * The name of the Function App. This name must be unique within Azure.
+     */
+    readonly name: string;
+    /**
+     * The Azure Region where the Function App will be deployed, e.g., 'East US', 'West Europe'.
+     */
+    readonly location: string;
+    /**
+     * An optional reference to the resource group in which to deploy the Function App.
+     * If not provided, the Function App will be deployed in the default resource group.
+     */
+    readonly resourceGroup?: ResourceGroup;
+    /**
+     * An optional reference to the storage account to be used by the Function App.
+     * If not provided, a new storage account will be created.
+     */
+    readonly storageAccount?: StorageAccount;
+    /**
+     * Optional runtime version specification for the Function App, such as Node.js, .NET, or Java version.
+     */
+    readonly runtimeVersion?: LinuxFunctionAppSiteConfigApplicationStack;
+    /**
+     * Optional ID of an existing App Service Plan to host the Function App.
+     * If not provided, a new plan will be created.
+     */
+    readonly servicePlan?: ServicePlan;
+    /**
+     * Optional SKU for the App Service Plan, defines the pricing tier and capabilities.
+     */
+    readonly servicePlanSku?: string;
+    /**
+     * Optional tags for categorizing and managing the Function App resources within Azure.
+     */
+    readonly tags?: {
+        [key: string]: string;
+    };
+    /**
+     * Optional site configuration for additional settings like environment variables, and connection strings.
+     */
+    readonly siteConfig?: LinuxFunctionAppSiteConfig;
+    /**
+     * Optional ID for the App Service Environment to be used by the service plan.
+     */
+    readonly servicePlanAppServiceEnvironmentId?: string;
+    /**
+     * Optional maximum count of elastic workers for the App Service Plan.
+     */
+    readonly servicePlanMaximumElasticWorkerCount?: number;
+    /**
+     * Optional worker count for the App Service Plan.
+     */
+    readonly servicePlanWorkerCount?: number;
+    /**
+     * Optional flag to enable per-site scaling for the App Service Plan.
+     */
+    readonly servicePlanPerSiteScalingEnabled?: boolean;
+    /**
+     * Optional flag to enable zone balancing for the App Service Plan.
+     */
+    readonly servicePlanZoneBalancingEnabled?: boolean;
+    /**
+     * Optional authentication settings for the Function App.
+     */
+    readonly authSettings?: LinuxFunctionAppAuthSettings;
+    /**
+     * Optional advanced version of authentication settings for the Function App.
+     */
+    readonly authSettingsV2?: LinuxFunctionAppAuthSettingsV2;
+    /**
+     * Optional identity configuration for the Function App, for use in Managed Service Identity scenarios.
+     */
+    readonly identity?: LinuxFunctionAppIdentity;
+    /**
+     * Optional flag to enforce HTTPS only traffic.
+     */
+    readonly httpsOnly?: boolean;
+    /**
+     * Optional flag to enable client certificate authentication.
+     */
+    readonly clientCertificateEnabled?: boolean;
+    /**
+     * Optional mode for client certificate requirement (e.g., 'Required', 'Optional').
+     */
+    readonly clientCertificateMode?: string;
+    /**
+     * Optional paths that are excluded from client certificate authentication.
+     */
+    readonly clientCertificateExclusionPaths?: string;
+    /**
+     * Optional version setting for the Azure Functions runtime.
+     */
+    readonly functionsExtensionVersion?: string;
+    /**
+     * Optional flag to enable or disable the Function App.
+     */
+    readonly enabled?: boolean;
+    /**
+     * Optional flag to enable built-in logging capabilities.
+     */
+    readonly builtinLoggingEnabled?: boolean;
+    /**
+     * Optional connection string for external services or databases.
+     */
+    readonly connectionString?: LinuxFunctionAppConnectionString[];
+    /**
+     * Optional flag to enable or disable public network access to the Function App.
+     */
+    readonly publicNetworkAccessEnabled?: boolean;
+    /**
+     * Optional flag indicating if the storage account uses a Managed Identity.
+     */
+    readonly storageUsesManagedIdentity?: boolean;
+    /**
+     * Optional access key for the storage account.
+     */
+    readonly storageAccountAccessKey?: string;
+    /**
+     * Optional ID of a virtual network subnet for the Function App.
+     */
+    readonly virtualNetworkSubnetId?: string;
+    /**
+     * Optional path to a ZIP file for deployment to the Function App.
+     */
+    readonly zipDeployFile?: string;
+    /**
+     * Application settings for the Azure Function App.
+     *
+     * @property { [key: string]: string } appSettings - A collection of key-value pairs that contain the settings.
+     *
+     * Note on Runtime Settings:
+     * - 'node_version' in 'site_config' sets the Node.js version.
+     *   Terraform assigns this value to 'WEBSITE_NODE_DEFAULT_VERSION' in app settings.
+     * - 'functions_extension_version' sets the Azure Functions runtime version.
+     *   Terraform assigns this value to 'FUNCTIONS_EXTENSION_VERSION' in app settings.
+     *
+     * Note on Storage Settings:
+     * - Properties like 'storage_account_access_key' are used for storage configurations.
+     *   Terraform assigns these values to keys like 'WEBSITE_CONTENTAZUREFILECONNECTIONSTRING',
+     *   'AzureWebJobsStorage' in app settings.
+     *
+     * Note on Application Insights Settings:
+     * - Use 'application_insights_connection_string' and 'application_insights_key' for Application Insights configurations.
+     *   Terraform assigns these to 'APPINSIGHTS_INSTRUMENTATIONKEY' and 'APPLICATIONINSIGHTS_CONNECTION_STRING' in app settings.
+     *
+     * Note on Health Check Settings:
+     * - 'health_check_eviction_time_in_min' configures health check settings.
+     *   Terraform assigns this value to 'WEBSITE_HEALTHCHECK_MAXPINGFAILURES' in app settings.
+     *
+     * Note on Storage Account Restriction:
+     * - To restrict your storage account to a virtual network, set 'WEBSITE_CONTENTOVERVNET' to 1 in app settings.
+     *   Ensure a predefined share is created for this configuration.
+     */
+    readonly appSettings?: {
+        [key: string]: string;
+    };
+}
+export declare class FunctionAppLinux extends AzureResource {
+    id: string;
+    readonly defaultHostname: string;
+    readonly kind: string;
+    readonly name: string;
+    readonly storageAccount: StorageAccount;
+    readonly servicePlan: ServicePlan;
+    resourceGroup: ResourceGroup;
+    /**
+     * Constructs a new FunctionAppLinux.
+     *
+     * @param scope - The scope in which to define this construct.
+     * @param id - The ID of this construct.
+     * @param props - The properties for configuring the Azure Function App on Linux. The properties include:
+     *                - `name`: Required. Unique name for the Function App within Azure.
+     *                - `location`: Required. Azure Region for deployment.
+     *                - `resourceGroup`: Optional. Reference to the resource group for deployment.
+     *                - `storageAccount`: Optional. Reference to the storage account used by the Function App.
+     *                - `runtimeVersion`: Optional. Specifies the runtime version (Node.js, .NET, Java, etc.).
+     *                - `servicePlan`: Optional. ID of an existing App Service Plan.
+     *                - `servicePlanSku`: Optional. SKU for the App Service Plan.
+     *                - `tags`: Optional. Tags for resource management.
+     *                - `siteConfig`: Optional. Additional site configuration settings.
+     *                - Additional optional properties as described in `FunctionAppLinuxProps` interface.
+     *
+     * Example usage:
+     * ```typescript
+     * new FunctionAppLinux(this, 'premiumFA', {
+     *   name: `faprem${this.name}`,
+     *   location: 'eastus',
+     *   servicePlanSku: ServicePlanSkus.PremiumEP1,
+     *   runtimeVersion: {
+     *     dotnetVersion: '5.0',
+     *   },
+     *   tags: {
+     *     "test": "test"
+     *   }
+     * });
+     * ```
+     */
+    constructor(scope: Construct, id: string, props: FunctionAppLinuxProps);
+    private setupStorageAccount;
+    private setupServicePlan;
+}

package/lib/azure-functionapp/lib/functionapplinux.js

@@ -0,0 +1,141 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionAppLinux = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const linux_function_app_1 = require("@cdktf/provider-azurerm/lib/linux-function-app");
+const service_plan_1 = require("@cdktf/provider-azurerm/lib/service-plan");
+const storage_account_1 = require("@cdktf/provider-azurerm/lib/storage-account");
+const lib_1 = require("../../core-azure/lib");
+class FunctionAppLinux extends lib_1.AzureResource {
+    /**
+     * Constructs a new FunctionAppLinux.
+     *
+     * @param scope - The scope in which to define this construct.
+     * @param id - The ID of this construct.
+     * @param props - The properties for configuring the Azure Function App on Linux. The properties include:
+     *                - `name`: Required. Unique name for the Function App within Azure.
+     *                - `location`: Required. Azure Region for deployment.
+     *                - `resourceGroup`: Optional. Reference to the resource group for deployment.
+     *                - `storageAccount`: Optional. Reference to the storage account used by the Function App.
+     *                - `runtimeVersion`: Optional. Specifies the runtime version (Node.js, .NET, Java, etc.).
+     *                - `servicePlan`: Optional. ID of an existing App Service Plan.
+     *                - `servicePlanSku`: Optional. SKU for the App Service Plan.
+     *                - `tags`: Optional. Tags for resource management.
+     *                - `siteConfig`: Optional. Additional site configuration settings.
+     *                - Additional optional properties as described in `FunctionAppLinuxProps` interface.
+     *
+     * Example usage:
+     * ```typescript
+     * new FunctionAppLinux(this, 'premiumFA', {
+     *   name: `faprem${this.name}`,
+     *   location: 'eastus',
+     *   servicePlanSku: ServicePlanSkus.PremiumEP1,
+     *   runtimeVersion: {
+     *     dotnetVersion: '5.0',
+     *   },
+     *   tags: {
+     *     "test": "test"
+     *   }
+     * });
+     * ```
+     */
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.resourceGroup = this.setupResourceGroup(props);
+        this.storageAccount = this.setupStorageAccount(props);
+        this.servicePlan = this.setupServicePlan(props);
+        this.resourceGroup = this.resourceGroup;
+        // Default siteConfig settings for each hosting plan
+        let defaultSiteConfig = {
+            use32BitWorker: false,
+            applicationStack: {
+                nodeVersion: "14",
+            },
+        };
+        // Merge user provided siteConfig with defaults
+        const siteConfig = { ...defaultSiteConfig, ...props.siteConfig };
+        const defaults = {
+            httpsOnly: props.httpsOnly || true,
+            clientCertificateEnabled: props.clientCertificateEnabled || false,
+            clientCertificateMode: props.clientCertificateMode || "Required",
+            identity: props.identity || { type: "SystemAssigned" },
+            clientCertificateExclusionPaths: props.clientCertificateExclusionPaths || "",
+            functionsExtensionVersion: props.functionsExtensionVersion || "~4",
+            enabled: props.enabled || true,
+            builtinLoggingEnabled: props.builtinLoggingEnabled || true,
+            publicNetworkAccessEnabled: props.publicNetworkAccessEnabled || true,
+            storageUsesManagedIdentity: props.storageUsesManagedIdentity || true,
+            storageAccountAccessKey: undefined || props.storageAccountAccessKey,
+        };
+        // Create the Function App
+        const functionApp = new linux_function_app_1.LinuxFunctionApp(this, "FunctionApp", {
+            ...defaults,
+            name: props.name,
+            location: props.location,
+            resourceGroupName: this.resourceGroup.name,
+            servicePlanId: this.servicePlan.id,
+            storageAccountName: this.storageAccount.name,
+            tags: props.tags,
+            siteConfig: siteConfig,
+            appSettings: props.appSettings,
+            authSettings: props.authSettings,
+            authSettingsV2: props.authSettingsV2,
+            connectionString: props.connectionString,
+            virtualNetworkSubnetId: props.virtualNetworkSubnetId,
+            zipDeployFile: props.zipDeployFile,
+        });
+        this.id = functionApp.id;
+        this.defaultHostname = functionApp.defaultHostname;
+        this.kind = functionApp.kind;
+        this.name = functionApp.name;
+    }
+    setupStorageAccount(props) {
+        // Reference or create a new storage account that will be used by the Function App to store files
+        if (!props.storageAccount) {
+            return new storage_account_1.StorageAccount(this, "sa", {
+                name: `${props.name}stacc`,
+                resourceGroupName: this.resourceGroup.name,
+                location: props.location,
+                accountReplicationType: "LRS",
+                accountTier: "Standard",
+                minTlsVersion: "TLS1_2",
+                tags: props.tags,
+                publicNetworkAccessEnabled: false,
+                networkRules: {
+                    bypass: ["AzureServices"],
+                    defaultAction: "Deny",
+                },
+            });
+        }
+        else {
+            return props.storageAccount;
+        }
+    }
+    setupServicePlan(props) {
+        const servicePlanSKU = props.servicePlanSku || "Y1";
+        // Use an existing App Service Plan if the ID is provided, otherwise create a new one
+        if (!props.servicePlan) {
+            return new service_plan_1.ServicePlan(this, "AppServicePlan", {
+                name: `${props.name}asp`,
+                location: props.location,
+                resourceGroupName: this.resourceGroup.name,
+                skuName: servicePlanSKU,
+                osType: "Linux",
+                appServiceEnvironmentId: props.servicePlanAppServiceEnvironmentId,
+                maximumElasticWorkerCount: props.servicePlanMaximumElasticWorkerCount,
+                workerCount: props.servicePlanWorkerCount,
+                perSiteScalingEnabled: props.servicePlanPerSiteScalingEnabled,
+                zoneBalancingEnabled: props.servicePlanZoneBalancingEnabled,
+                tags: props.tags,
+            });
+        }
+        else {
+            return props.servicePlan;
+        }
+    }
+}
+exports.FunctionAppLinux = FunctionAppLinux;
+_a = JSII_RTTI_SYMBOL_1;
+FunctionAppLinux[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_functionapp.FunctionAppLinux", version: "0.0.3-pre.10" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"functionapplinux.js","sourceRoot":"","sources":["../../../src/azure-functionapp/lib/functionapplinux.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  LinuxFunctionApp,\n  LinuxFunctionAppSiteConfig,\n  LinuxFunctionAppSiteConfigApplicationStack,\n  LinuxFunctionAppAuthSettings,\n  LinuxFunctionAppAuthSettingsV2,\n  LinuxFunctionAppIdentity,\n  LinuxFunctionAppConnectionString,\n} from \"@cdktf/provider-azurerm/lib/linux-function-app\";\nimport { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\nimport { ServicePlan } from \"@cdktf/provider-azurerm/lib/service-plan\";\nimport { StorageAccount } from \"@cdktf/provider-azurerm/lib/storage-account\";\nimport { Construct } from \"constructs\";\nimport { AzureResource } from \"../../core-azure/lib\";\n\n/**\n * Properties for the Azure Linux Function App\n */\nexport interface FunctionAppLinuxProps {\n  /**\n   * The name of the Function App. This name must be unique within Azure.\n   */\n  readonly name: string;\n\n  /**\n   * The Azure Region where the Function App will be deployed, e.g., 'East US', 'West Europe'.\n   */\n  readonly location: string;\n\n  /**\n   * An optional reference to the resource group in which to deploy the Function App.\n   * If not provided, the Function App will be deployed in the default resource group.\n   */\n  readonly resourceGroup?: ResourceGroup;\n\n  /**\n   * An optional reference to the storage account to be used by the Function App.\n   * If not provided, a new storage account will be created.\n   */\n  readonly storageAccount?: StorageAccount;\n\n  /**\n   * Optional runtime version specification for the Function App, such as Node.js, .NET, or Java version.\n   */\n  readonly runtimeVersion?: LinuxFunctionAppSiteConfigApplicationStack;\n\n  /**\n   * Optional ID of an existing App Service Plan to host the Function App.\n   * If not provided, a new plan will be created.\n   */\n  readonly servicePlan?: ServicePlan;\n\n  /**\n   * Optional SKU for the App Service Plan, defines the pricing tier and capabilities.\n   */\n  readonly servicePlanSku?: string;\n\n  /**\n   * Optional tags for categorizing and managing the Function App resources within Azure.\n   */\n  readonly tags?: { [key: string]: string };\n\n  /**\n   * Optional site configuration for additional settings like environment variables, and connection strings.\n   */\n  readonly siteConfig?: LinuxFunctionAppSiteConfig;\n\n  /**\n   * Optional ID for the App Service Environment to be used by the service plan.\n   */\n  readonly servicePlanAppServiceEnvironmentId?: string;\n\n  /**\n   * Optional maximum count of elastic workers for the App Service Plan.\n   */\n  readonly servicePlanMaximumElasticWorkerCount?: number;\n\n  /**\n   * Optional worker count for the App Service Plan.\n   */\n  readonly servicePlanWorkerCount?: number;\n\n  /**\n   * Optional flag to enable per-site scaling for the App Service Plan.\n   */\n  readonly servicePlanPerSiteScalingEnabled?: boolean;\n\n  /**\n   * Optional flag to enable zone balancing for the App Service Plan.\n   */\n  readonly servicePlanZoneBalancingEnabled?: boolean;\n\n  /**\n   * Optional authentication settings for the Function App.\n   */\n  readonly authSettings?: LinuxFunctionAppAuthSettings;\n\n  /**\n   * Optional advanced version of authentication settings for the Function App.\n   */\n  readonly authSettingsV2?: LinuxFunctionAppAuthSettingsV2;\n\n  /**\n   * Optional identity configuration for the Function App, for use in Managed Service Identity scenarios.\n   */\n  readonly identity?: LinuxFunctionAppIdentity;\n\n  /**\n   * Optional flag to enforce HTTPS only traffic.\n   */\n  readonly httpsOnly?: boolean;\n\n  /**\n   * Optional flag to enable client certificate authentication.\n   */\n  readonly clientCertificateEnabled?: boolean;\n\n  /**\n   * Optional mode for client certificate requirement (e.g., 'Required', 'Optional').\n   */\n  readonly clientCertificateMode?: string;\n\n  /**\n   * Optional paths that are excluded from client certificate authentication.\n   */\n  readonly clientCertificateExclusionPaths?: string;\n\n  /**\n   * Optional version setting for the Azure Functions runtime.\n   */\n  readonly functionsExtensionVersion?: string;\n\n  /**\n   * Optional flag to enable or disable the Function App.\n   */\n  readonly enabled?: boolean;\n\n  /**\n   * Optional flag to enable built-in logging capabilities.\n   */\n  readonly builtinLoggingEnabled?: boolean;\n\n  /**\n   * Optional connection string for external services or databases.\n   */\n  readonly connectionString?: LinuxFunctionAppConnectionString[];\n\n  /**\n   * Optional flag to enable or disable public network access to the Function App.\n   */\n  readonly publicNetworkAccessEnabled?: boolean;\n\n  /**\n   * Optional flag indicating if the storage account uses a Managed Identity.\n   */\n  readonly storageUsesManagedIdentity?: boolean;\n\n  /**\n   * Optional access key for the storage account.\n   */\n  readonly storageAccountAccessKey?: string;\n\n  /**\n   * Optional ID of a virtual network subnet for the Function App.\n   */\n  readonly virtualNetworkSubnetId?: string;\n\n  /**\n   * Optional path to a ZIP file for deployment to the Function App.\n   */\n  readonly zipDeployFile?: string;\n\n  /**\n   * Application settings for the Azure Function App.\n   *\n   * @property { [key: string]: string } appSettings - A collection of key-value pairs that contain the settings.\n   *\n   * Note on Runtime Settings:\n   * - 'node_version' in 'site_config' sets the Node.js version.\n   *   Terraform assigns this value to 'WEBSITE_NODE_DEFAULT_VERSION' in app settings.\n   * - 'functions_extension_version' sets the Azure Functions runtime version.\n   *   Terraform assigns this value to 'FUNCTIONS_EXTENSION_VERSION' in app settings.\n   *\n   * Note on Storage Settings:\n   * - Properties like 'storage_account_access_key' are used for storage configurations.\n   *   Terraform assigns these values to keys like 'WEBSITE_CONTENTAZUREFILECONNECTIONSTRING',\n   *   'AzureWebJobsStorage' in app settings.\n   *\n   * Note on Application Insights Settings:\n   * - Use 'application_insights_connection_string' and 'application_insights_key' for Application Insights configurations.\n   *   Terraform assigns these to 'APPINSIGHTS_INSTRUMENTATIONKEY' and 'APPLICATIONINSIGHTS_CONNECTION_STRING' in app settings.\n   *\n   * Note on Health Check Settings:\n   * - 'health_check_eviction_time_in_min' configures health check settings.\n   *   Terraform assigns this value to 'WEBSITE_HEALTHCHECK_MAXPINGFAILURES' in app settings.\n   *\n   * Note on Storage Account Restriction:\n   * - To restrict your storage account to a virtual network, set 'WEBSITE_CONTENTOVERVNET' to 1 in app settings.\n   *   Ensure a predefined share is created for this configuration.\n   */\n  readonly appSettings?: { [key: string]: string };\n}\n\nexport class FunctionAppLinux extends AzureResource {\n  public id: string;\n  public readonly defaultHostname: string;\n  public readonly kind: string;\n  public readonly name: string;\n  public readonly storageAccount: StorageAccount;\n  public readonly servicePlan: ServicePlan;\n  public resourceGroup: ResourceGroup;\n  /**\n   * Constructs a new FunctionAppLinux.\n   *\n   * @param scope - The scope in which to define this construct.\n   * @param id - The ID of this construct.\n   * @param props - The properties for configuring the Azure Function App on Linux. The properties include:\n   *                - `name`: Required. Unique name for the Function App within Azure.\n   *                - `location`: Required. Azure Region for deployment.\n   *                - `resourceGroup`: Optional. Reference to the resource group for deployment.\n   *                - `storageAccount`: Optional. Reference to the storage account used by the Function App.\n   *                - `runtimeVersion`: Optional. Specifies the runtime version (Node.js, .NET, Java, etc.).\n   *                - `servicePlan`: Optional. ID of an existing App Service Plan.\n   *                - `servicePlanSku`: Optional. SKU for the App Service Plan.\n   *                - `tags`: Optional. Tags for resource management.\n   *                - `siteConfig`: Optional. Additional site configuration settings.\n   *                - Additional optional properties as described in `FunctionAppLinuxProps` interface.\n   *\n   * Example usage:\n   * ```typescript\n   * new FunctionAppLinux(this, 'premiumFA', {\n   *   name: `faprem${this.name}`,\n   *   location: 'eastus',\n   *   servicePlanSku: ServicePlanSkus.PremiumEP1,\n   *   runtimeVersion: {\n   *     dotnetVersion: '5.0',\n   *   },\n   *   tags: {\n   *     \"test\": \"test\"\n   *   }\n   * });\n   * ```\n   */\n  constructor(scope: Construct, id: string, props: FunctionAppLinuxProps) {\n    super(scope, id);\n\n    this.resourceGroup = this.setupResourceGroup(props);\n    this.storageAccount = this.setupStorageAccount(props);\n    this.servicePlan = this.setupServicePlan(props);\n\n    this.resourceGroup = this.resourceGroup;\n\n    // Default siteConfig settings for each hosting plan\n    let defaultSiteConfig: LinuxFunctionAppSiteConfig = {\n      use32BitWorker: false,\n      applicationStack: {\n        nodeVersion: \"14\",\n      },\n    };\n\n    // Merge user provided siteConfig with defaults\n    const siteConfig = { ...defaultSiteConfig, ...props.siteConfig };\n\n    const defaults = {\n      httpsOnly: props.httpsOnly || true,\n      clientCertificateEnabled: props.clientCertificateEnabled || false,\n      clientCertificateMode: props.clientCertificateMode || \"Required\",\n      identity: props.identity || { type: \"SystemAssigned\" },\n      clientCertificateExclusionPaths:\n        props.clientCertificateExclusionPaths || \"\",\n      functionsExtensionVersion: props.functionsExtensionVersion || \"~4\",\n      enabled: props.enabled || true,\n      builtinLoggingEnabled: props.builtinLoggingEnabled || true,\n      publicNetworkAccessEnabled: props.publicNetworkAccessEnabled || true,\n      storageUsesManagedIdentity: props.storageUsesManagedIdentity || true,\n      storageAccountAccessKey: undefined || props.storageAccountAccessKey,\n    };\n\n    // Create the Function App\n    const functionApp = new LinuxFunctionApp(this, \"FunctionApp\", {\n      ...defaults,\n      name: props.name,\n      location: props.location,\n      resourceGroupName: this.resourceGroup.name,\n      servicePlanId: this.servicePlan.id,\n      storageAccountName: this.storageAccount.name,\n      tags: props.tags,\n      siteConfig: siteConfig,\n      appSettings: props.appSettings,\n      authSettings: props.authSettings,\n      authSettingsV2: props.authSettingsV2,\n      connectionString: props.connectionString,\n      virtualNetworkSubnetId: props.virtualNetworkSubnetId,\n      zipDeployFile: props.zipDeployFile,\n    });\n\n    this.id = functionApp.id;\n    this.defaultHostname = functionApp.defaultHostname;\n    this.kind = functionApp.kind;\n    this.name = functionApp.name;\n  }\n\n  private setupStorageAccount(props: FunctionAppLinuxProps): StorageAccount {\n    // Reference or create a new storage account that will be used by the Function App to store files\n    if (!props.storageAccount) {\n      return new StorageAccount(this, \"sa\", {\n        name: `${props.name}stacc`,\n        resourceGroupName: this.resourceGroup.name,\n        location: props.location,\n        accountReplicationType: \"LRS\",\n        accountTier: \"Standard\",\n        minTlsVersion: \"TLS1_2\",\n        tags: props.tags,\n        publicNetworkAccessEnabled: false,\n        networkRules: {\n          bypass: [\"AzureServices\"],\n          defaultAction: \"Deny\",\n        },\n      });\n    } else {\n      return props.storageAccount;\n    }\n  }\n\n  private setupServicePlan(props: FunctionAppLinuxProps): ServicePlan {\n    const servicePlanSKU = props.servicePlanSku || \"Y1\";\n\n    // Use an existing App Service Plan if the ID is provided, otherwise create a new one\n    if (!props.servicePlan) {\n      return new ServicePlan(this, \"AppServicePlan\", {\n        name: `${props.name}asp`,\n        location: props.location,\n        resourceGroupName: this.resourceGroup.name,\n        skuName: servicePlanSKU,\n        osType: \"Linux\",\n        appServiceEnvironmentId: props.servicePlanAppServiceEnvironmentId,\n        maximumElasticWorkerCount: props.servicePlanMaximumElasticWorkerCount,\n        workerCount: props.servicePlanWorkerCount,\n        perSiteScalingEnabled: props.servicePlanPerSiteScalingEnabled,\n        zoneBalancingEnabled: props.servicePlanZoneBalancingEnabled,\n        tags: props.tags,\n      });\n    } else {\n      return props.servicePlan;\n    }\n  }\n}\n"]}

package/lib/azure-functionapp/lib/index.d.ts

@@ -0,0 +1 @@
+export * from "./functionapplinux";

package/lib/azure-functionapp/lib/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./functionapplinux"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXp1cmUtZnVuY3Rpb25hcHAvbGliL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxxREFBbUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9mdW5jdGlvbmFwcGxpbnV4XCI7XG4iXX0=

package/lib/azure-functionapp/serviceplanskus.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Enum for Azure Service Plan SKUs.
+ */
+export declare enum ServicePlanSkus {
+    /**
+     * Consumption Plan: Automatically scales based on demand and billed per execution.
+     * No dedicated resources; suitable for event-driven and intermittent workloads.
+     */
+    Consumption = "Y1",
+    /**
+     * Premium Plan EP1: Offers more CPU and memory than Consumption Plan with features like VNet.
+     */
+    PremiumEP1 = "EP1",
+    /**
+     * Premium Plan EP2: Higher CPU and memory, suitable for more demanding workloads.
+     */
+    PremiumEP2 = "EP2",
+    /**
+     * Premium Plan EP3: Highest available CPU and memory in the Premium tier.
+     */
+    PremiumEP3 = "EP3",
+    /**
+     * Basic B1: Basic tier, more compute options than Free, suitable for small-scale production.
+     */
+    ASPBasicB1 = "B1",
+    /**
+     * Basic B2: Enhanced tier with more CPU and memory.
+     */
+    ASPBasicB2 = "B2",
+    /**
+     * Basic B3: Highest Basic tier with more CPU and memory.
+     */
+    ASPBasicB3 = "B3",
+    /**
+     * Standard S1: Suitable for production workloads with auto-scaling and staging slots.
+     */
+    ASPStandardS1 = "S1",
+    /**
+     * Standard S2: More CPU and memory than S1, suitable for larger workloads.
+     */
+    ASPStandardS2 = "S2",
+    /**
+     * Standard S3: Highest Standard tier, offering maximum available CPU and memory.
+     */
+    ASPStandardS3 = "S3",
+    /**
+     * Premium P1V2: Enhanced performance features and VNet integration.
+     */
+    ASPPremiumP1V2 = "P1V2",
+    /**
+     * Premium P2V2: Higher CPU and memory than P1V2.
+     */
+    ASPPremiumP2V2 = "P2V2",
+    /**
+     * Premium P3V2: Highest CPU and memory in the Premium category.
+     */
+    ASPPremiumP3V2 = "P3V2",
+    /**
+     * Isolated I1: Dedicated environment for highest compliance and security.
+     */
+    ASPIsolatedI1 = "I1",
+    /**
+     * Isolated I2: Enhanced isolated plan with more resources.
+     */
+    ASPIsolatedI2 = "I2",
+    /**
+     * Isolated I3: Top-tier isolated plan with maximum resources.
+     */
+    ASPIsolatedI3 = "I3"
+}

package/lib/azure-functionapp/serviceplanskus.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServicePlanSkus = void 0;
+/**
+ * Enum for Azure Service Plan SKUs.
+ */
+var ServicePlanSkus;
+(function (ServicePlanSkus) {
+    // Consumption Plan
+    /**
+     * Consumption Plan: Automatically scales based on demand and billed per execution.
+     * No dedicated resources; suitable for event-driven and intermittent workloads.
+     */
+    ServicePlanSkus["Consumption"] = "Y1";
+    // Premium Plan (EP = Elastic Premium)
+    /**
+     * Premium Plan EP1: Offers more CPU and memory than Consumption Plan with features like VNet.
+     */
+    ServicePlanSkus["PremiumEP1"] = "EP1";
+    /**
+     * Premium Plan EP2: Higher CPU and memory, suitable for more demanding workloads.
+     */
+    ServicePlanSkus["PremiumEP2"] = "EP2";
+    /**
+     * Premium Plan EP3: Highest available CPU and memory in the Premium tier.
+     */
+    ServicePlanSkus["PremiumEP3"] = "EP3";
+    // App Service Plan - Basic
+    /**
+     * Basic B1: Basic tier, more compute options than Free, suitable for small-scale production.
+     */
+    ServicePlanSkus["ASPBasicB1"] = "B1";
+    /**
+     * Basic B2: Enhanced tier with more CPU and memory.
+     */
+    ServicePlanSkus["ASPBasicB2"] = "B2";
+    /**
+     * Basic B3: Highest Basic tier with more CPU and memory.
+     */
+    ServicePlanSkus["ASPBasicB3"] = "B3";
+    // App Service Plan - Standard
+    /**
+     * Standard S1: Suitable for production workloads with auto-scaling and staging slots.
+     */
+    ServicePlanSkus["ASPStandardS1"] = "S1";
+    /**
+     * Standard S2: More CPU and memory than S1, suitable for larger workloads.
+     */
+    ServicePlanSkus["ASPStandardS2"] = "S2";
+    /**
+     * Standard S3: Highest Standard tier, offering maximum available CPU and memory.
+     */
+    ServicePlanSkus["ASPStandardS3"] = "S3";
+    // App Service Plan - Premium
+    /**
+     * Premium P1V2: Enhanced performance features and VNet integration.
+     */
+    ServicePlanSkus["ASPPremiumP1V2"] = "P1V2";
+    /**
+     * Premium P2V2: Higher CPU and memory than P1V2.
+     */
+    ServicePlanSkus["ASPPremiumP2V2"] = "P2V2";
+    /**
+     * Premium P3V2: Highest CPU and memory in the Premium category.
+     */
+    ServicePlanSkus["ASPPremiumP3V2"] = "P3V2";
+    // App Service Plan - Isolated
+    /**
+     * Isolated I1: Dedicated environment for highest compliance and security.
+     */
+    ServicePlanSkus["ASPIsolatedI1"] = "I1";
+    /**
+     * Isolated I2: Enhanced isolated plan with more resources.
+     */
+    ServicePlanSkus["ASPIsolatedI2"] = "I2";
+    /**
+     * Isolated I3: Top-tier isolated plan with maximum resources.
+     */
+    ServicePlanSkus["ASPIsolatedI3"] = "I3";
+})(ServicePlanSkus || (exports.ServicePlanSkus = ServicePlanSkus = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/lib/azure-functionapp/test/AzureLinuxFunctionApp.spec.d.ts

@@ -0,0 +1 @@
+import "cdktf/lib/testing/adapters/jest";

package/lib/azure-functionapp/test/AzureLinuxFunctionApp.spec.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const provider_1 = require("@cdktf/provider-azurerm/lib/provider");
+const cdktf_1 = require("cdktf");
+require("cdktf/lib/testing/adapters/jest");
+const ExampleAzureLinuxFunctionApp_1 = require("./ExampleAzureLinuxFunctionApp");
+const func = require("..");
+const util = require("../../util/azureTenantIdHelpers");
+describe("Azure Linux Function App With Defaults", () => {
+    let stack;
+    let fullSynthResult;
+    beforeEach(() => {
+        const app = cdktf_1.Testing.app();
+        stack = new cdktf_1.TerraformStack(app, "test");
+        new provider_1.AzurermProvider(stack, "azureFeature", { features: {} });
+        new func.FunctionAppLinux(stack, "testAzureLinuxFunctionApp", {
+            name: "fatest",
+            location: "eastus",
+        });
+        fullSynthResult = cdktf_1.Testing.fullSynth(stack); // Save the result for reuse
+    });
+    it("renders an Azure Linux Function App with defaults and checks snapshot", () => {
+        expect(cdktf_1.Testing.synth(stack)).toMatchSnapshot(); // Compare the already prepared stack
+    });
+    it("check if the produced terraform configuration is valid", () => {
+        expect(fullSynthResult).toBeValidTerraform(); // Use the saved result
+    });
+    it("check if this can be planned", () => {
+        expect(fullSynthResult).toPlanSuccessfully(); // Use the saved result
+    });
+});
+describe("Linux Function App Example", () => {
+    it("renders the Linux Function App and checks snapshot", () => {
+        // Need to remove the tenant_id from the snapshot as it will change wherever the test is run
+        const output = cdktf_1.Testing.synth(new ExampleAzureLinuxFunctionApp_1.exampleAzureLinuxFunctionApp(cdktf_1.Testing.app(), "testAzureLinuxFunctionApp"));
+        const myObject = JSON.parse(output);
+        expect(util.removeTenantIdFromSnapshot(myObject)).toMatchSnapshot();
+    });
+    it("check if the produced terraform configuration is valid", () => {
+        // We need to do a full synth to plan the terraform configuration
+        expect(cdktf_1.Testing.fullSynth(new ExampleAzureLinuxFunctionApp_1.exampleAzureLinuxFunctionApp(cdktf_1.Testing.app(), "testAzureLinuxFunctionApp"))).toBeValidTerraform();
+    });
+    it("check if this can be planned", () => {
+        // We need to do a full synth to plan the terraform configuration
+        expect(cdktf_1.Testing.fullSynth(new ExampleAzureLinuxFunctionApp_1.exampleAzureLinuxFunctionApp(cdktf_1.Testing.app(), "testAzureLinuxFunctionApp"))).toPlanSuccessfully();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/azure-functionapp/test/ExampleAzureLinuxFunctionApp.d.ts

@@ -0,0 +1,5 @@
+import { Construct } from "constructs";
+import { BaseTestStack } from "../../testing";
+export declare class exampleAzureLinuxFunctionApp extends BaseTestStack {
+    constructor(scope: Construct, id: string);
+}