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

package/lib/azure-keyvault/lib/vault.js

@@ -0,0 +1,392 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vault = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const key_vault_1 = require("@cdktf/provider-azurerm/lib/key-vault");
+const cdktf = require("cdktf");
+const certificate_1 = require("./certificate");
+const key_1 = require("./key");
+const policy_1 = require("./policy");
+const secret_1 = require("./secret");
+const lib_1 = require("../../core-azure/lib");
+class Vault extends lib_1.AzureResource {
+    /**
+     * Constructs a new Azure Key Vault resource.
+     *
+     * This class creates and configures an Azure Key Vault, a secure store for managing secrets, keys, certificates, and other sensitive data.
+     * It supports advanced configurations such as access policies, network rules, and data retention policies.
+     *
+     * @param scope - The scope in which to define this construct, usually representing the Cloud Development Kit (CDK) stack.
+     * @param id - The unique identifier for this instance of the Key Vault.
+     * @param props - The properties for creating the Key Vault as defined in VaultProps. These include settings for location, SKU, tenant ID, etc.
+     *
+     * Example usage:
+     * ```typescript
+     * new Vault(this, 'MyKeyVault', {
+     *   name: 'mySecureVault',
+     *   location: 'East US',
+     *   resourceGroup: myResourceGroup,
+     *   sku: 'premium',
+     *   tenantId: 'my-tenant-id',
+     *   softDeleteRetentionDays: 90,
+     *   purgeProtection: true,
+     *   tags: {
+     *     project: 'My Application'
+     *   }
+     * });
+     * ```
+     */
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.accessPolicies = [];
+        this.props = props;
+        this.resourceGroup = props.resourceGroup;
+        // Provide default values
+        const purgeProtection = props.purgeProtection ?? true;
+        const sku = props.sku ?? "standard";
+        const softDeleteRetentionDays = props.softDeleteRetentionDays ?? 90;
+        const azurermKeyVault = new key_vault_1.KeyVault(this, "key_vault", {
+            name: props.name,
+            location: props.location,
+            resourceGroupName: props.resourceGroup.name,
+            tags: props.tags,
+            skuName: sku,
+            tenantId: props.tenantId,
+            networkAcls: props.networkAcls,
+            purgeProtectionEnabled: purgeProtection,
+            softDeleteRetentionDays: softDeleteRetentionDays,
+        });
+        this.id = azurermKeyVault.id;
+        this.keyVault = azurermKeyVault;
+        // Terraform Outputs
+        const cdktfTerraformOutputKeyVaultid = new cdktf.TerraformOutput(this, "id", {
+            value: azurermKeyVault.id,
+        });
+        /*This allows the Terraform resource name to match the original name. You can remove the call if you don't need them to match.*/
+        cdktfTerraformOutputKeyVaultid.overrideLogicalId("id");
+        const cdktfTerraformOutputKeyVaultname = new cdktf.TerraformOutput(this, "key_vault_name", {
+            value: azurermKeyVault.name,
+        });
+        /*This allows the Terraform resource name to match the original name. You can remove the call if you don't need them to match.*/
+        cdktfTerraformOutputKeyVaultname.overrideLogicalId("key_vault_name");
+    }
+    /**
+     * Grants read-only access to secrets stored in the Key Vault to a specified Azure AD group.
+     *
+     * @param azureAdGroupId - The Azure Active Directory group ID that will receive read access to secrets.
+     */
+    grantSecretReaderAccess(azureAdGroupId) {
+        const policyProps = {
+            keyVaultId: this,
+            tenantId: this.props.tenantId,
+            objectId: azureAdGroupId,
+            secretPermissions: ["Get", "List"],
+        };
+        const policy = new policy_1.AccessPolicy(this, `kv_secret_reader_access_${azureAdGroupId}`, policyProps);
+        this.accessPolicies.push(policy);
+    }
+    /**
+     * Grants administrative access to secrets stored in the Key Vault to a specified Azure AD group.
+     *
+     * @param azureAdGroupId - The Azure Active Directory group ID that will receive administrative access to secrets.
+     */
+    grantSecretAdminAccess(azureAdGroupId) {
+        const policyProps = {
+            keyVaultId: this,
+            tenantId: this.props.tenantId,
+            objectId: azureAdGroupId,
+            secretPermissions: [
+                "Get",
+                "List",
+                "Set",
+                "Delete",
+                "Backup",
+                "Restore",
+                "Recover",
+            ],
+        };
+        const policy = new policy_1.AccessPolicy(this, `kv_secret_admin_access_${azureAdGroupId}`, policyProps);
+        this.accessPolicies.push(policy);
+    }
+    /**
+     * Grants administrative access to certificates stored in the Key Vault to a specified Azure AD group.
+     *
+     * @param azureAdGroupId - The Azure Active Directory group ID that will receive administrative access to certificates.
+     */
+    grantCertAdminAccess(azureAdGroupId) {
+        const policyProps = {
+            keyVaultId: this,
+            tenantId: this.props.tenantId,
+            objectId: azureAdGroupId,
+            certificatePermissions: [
+                "Get",
+                "List",
+                "Set",
+                "Delete",
+                "Backup",
+                "Restore",
+                "Recover",
+            ],
+        };
+        const policy = new policy_1.AccessPolicy(this, `kv_cert_admin_access_${azureAdGroupId}`, policyProps);
+        this.accessPolicies.push(policy);
+    }
+    /**
+     * Grants read-only access to certificates stored in the Key Vault to a specified Azure AD group.
+     *
+     * @param azureAdGroupId - The Azure Active Directory group ID that will receive read access to certificates.
+     */
+    grantCertReaderAccess(azureAdGroupId) {
+        const policyProps = {
+            keyVaultId: this,
+            tenantId: this.props.tenantId,
+            objectId: azureAdGroupId,
+            certificatePermissions: ["Get", "List"],
+        };
+        const policy = new policy_1.AccessPolicy(this, `kv_cert_reader_access_${azureAdGroupId}`, policyProps);
+        this.accessPolicies.push(policy);
+    }
+    /**
+     * Grants administrative access to keys stored in the Key Vault to a specified Azure AD group.
+     *
+     * @param azureAdGroupId - The Azure Active Directory group ID that will receive administrative access to keys.
+     */
+    grantKeyAdminAccess(azureAdGroupId) {
+        const policyProps = {
+            keyVaultId: this,
+            tenantId: this.props.tenantId,
+            objectId: azureAdGroupId,
+            keyPermissions: [
+                "Get",
+                "List",
+                "Set",
+                "Delete",
+                "Backup",
+                "Restore",
+                "Recover",
+            ],
+        };
+        const policy = new policy_1.AccessPolicy(this, `kv_key_admin_access_${azureAdGroupId}`, policyProps);
+        this.accessPolicies.push(policy);
+    }
+    /**
+     * Grants read-only access to keys stored in the Key Vault to a specified Azure AD group.
+     *
+     * @param azureAdGroupId - The Azure Active Directory group ID that will receive read access to keys.
+     */
+    grantKeyReaderAccess(azureAdGroupId) {
+        const policyProps = {
+            keyVaultId: this,
+            tenantId: this.props.tenantId,
+            objectId: azureAdGroupId,
+            keyPermissions: ["Get", "List"],
+        };
+        const policy = new policy_1.AccessPolicy(this, `kv_key_reader_access_${azureAdGroupId}`, policyProps);
+        this.accessPolicies.push(policy);
+    }
+    /**
+     * Grants custom access based on specified options to an Azure AD group in the Key Vault.
+     *
+     * @param azureAdGroupId - The Azure Active Directory group ID that will receive the custom access.
+     * @param options - Custom access options specifying various permissions for secrets, keys, certificates, and storage.
+     */
+    grantCustomAccess(azureAdGroupId, options) {
+        const policyProps = {
+            keyVaultId: this,
+            tenantId: this.props.tenantId,
+            objectId: azureAdGroupId,
+            ...options,
+        };
+        const policy = new policy_1.AccessPolicy(this, `kv_custom_policy_access_${azureAdGroupId}`, policyProps);
+        this.accessPolicies.push(policy);
+    }
+    /**
+     * Creates a new secret within the Azure Key Vault.
+     *
+     * This method facilitates the storage of sensitive information in the form of a secret within the Key Vault.
+     * Secrets are protected items such as passwords, database connection strings, or any other piece of information
+     * that needs to be securely stored and accessed. This method allows setting additional properties such as
+     * expiration date and content type for better management and compliance.
+     *
+     * @param keyVaultSecretName - The unique name for the secret within the Key Vault.
+     * @param secretValue - The sensitive information or data that needs to be securely stored as a secret.
+     * @param expirationDate - Optional. The expiration date of the secret in ISO 8601 format (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SSZ).
+     *                         If provided, the secret will no longer be valid after this date.
+     * @param contentType - Optional. A description of the type of information the secret contains (e.g., 'password', 'connectionString').
+     *                      This can be used by applications to handle the secret appropriately.
+     *
+     * Example usage:
+     * ```typescript
+     * vault.addSecret(
+     *   'myDatabasePassword',
+     *   'p@ssw0rd123!',
+     *   '2030-01-01',
+     *   'databasePassword'
+     * );
+     * ```
+     * This method does not return a value. It creates a secret within the Key Vault with the specified properties.
+     */
+    addSecret(keyVaultSecretName, secretValue, expirationDate, contentType) {
+        const secretProps = {
+            keyVaultId: this,
+            name: keyVaultSecretName,
+            value: secretValue,
+            expirationDate: expirationDate,
+            contentType: contentType,
+            accessPolicies: this.accessPolicies,
+        };
+        new secret_1.Secret(this, keyVaultSecretName, secretProps);
+    }
+    /**
+     * Creates an RSA cryptographic key within the Azure Key Vault.
+     *
+     * This method facilitates the creation of an RSA key, which is useful for a variety of cryptographic operations such as
+     * encryption, decryption, digital signature verification, and more. The RSA key created by this method is configurable
+     * with an optional expiration date and a default key size of 2048 bits. The key operations allowed include decryption,
+     * encryption, signing, verifying signatures, and key wrapping/unwrapping.
+     *
+     * @param keyVaultKeyName - The unique name for the RSA key within the Key Vault.
+     * @param expirationDate - Optional. The expiration date of the key in ISO 8601 format (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SSZ).
+     *                         If provided, the key will no longer be valid after this date.
+     * @returns A KeyVaultKey object representing the newly created RSA key within the vault.
+     *
+     * Example usage:
+     * ```typescript
+     * const rsaKey = vault.addRSAKey(
+     *   'myRSAKey',
+     *   '2030-01-01'
+     * );
+     * ```
+     * This method returns the created KeyVaultKey object, allowing further operations or references to the key.
+     */
+    addRSAKey(keyVaultKeyName, expirationDate) {
+        const keyProps = {
+            keyVaultId: this,
+            name: keyVaultKeyName,
+            keyType: "RSA",
+            keySize: 2048,
+            keyOpts: ["decrypt", "encrypt", "sign", "unwrapKey", "verify", "wrapKey"],
+            expires: expirationDate,
+            accessPolicies: this.accessPolicies,
+        };
+        const key = new key_1.Key(this, keyVaultKeyName, keyProps);
+        return key.vaultKey;
+    }
+    /**
+     * Creates a cryptographic key within the Azure Key Vault.
+     *
+     * This method allows the creation of a cryptographic key of specified type and size within the Key Vault. The key can be
+     * configured with specific operations it can perform, such as encryption, decryption, signing, etc. An optional expiration
+     * date can also be set to control the key's lifecycle. This method is flexible, supporting various key types and sizes,
+     * making it suitable for a wide range of cryptographic needs.
+     *
+     * @param keyVaultKeyName - The unique name for the cryptographic key within the Key Vault.
+     * @param keyType - The type of cryptographic key to create (e.g., 'RSA', 'EC', 'oct-HSM').
+     * @param keySize - The size of the cryptographic key in bits (e.g., 2048, 3072, 4096 for RSA).
+     * @param keyOpts - A list of cryptographic operations that the key is allowed to perform. Possible values might include
+     *                  'encrypt', 'decrypt', 'sign', 'verify', 'wrapKey', 'unwrapKey'.
+     * @param expirationDate - Optional. The expiration date of the key in ISO 8601 format (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SSZ).
+     *                         If provided, the key will no longer be valid after this date, aligning with best practices for key management.
+     * @returns A KeyVaultKey object representing the newly created cryptographic key within the vault.
+     *
+     * Example usage:
+     * ```typescript
+     * const myKey = vault.addKey(
+     *   'myKey',
+     *   'RSA',
+     *   2048,
+     *   ['encrypt', 'decrypt', 'sign', 'verify'],
+     *   '2030-12-31'
+     * );
+     * ```
+     * This method returns the created KeyVaultKey object, enabling immediate use within the application for cryptographic operations.
+     */
+    addKey(keyVaultKeyName, keyType, keySize, keyOpts, expirationDate) {
+        const keyProps = {
+            keyVaultId: this,
+            name: keyVaultKeyName,
+            keyType: keyType,
+            keySize: keySize,
+            keyOpts: keyOpts,
+            expires: expirationDate,
+            accessPolicies: this.accessPolicies,
+        };
+        const key = new key_1.Key(this, keyVaultKeyName, keyProps);
+        return key.vaultKey;
+    }
+    /**
+     * Creates a self-signed certificate within the Azure Key Vault.
+     *
+     * This method facilitates the creation of a self-signed certificate, which is a digital certificate that is signed by
+     * its own creator rather than a trusted authority. Self-signed certificates can be useful for testing, internal
+     * communications, or any scenario where public trust is not required. The method allows specifying subject details,
+     * DNS names for the certificate, and managing its lifecycle with action types and expiry.
+     *
+     * @param certName - The unique name for the certificate within the Key Vault.
+     * @param subject - The subject name of the certificate, typically formatted as an X.500 Distinguished Name (e.g., "CN=example.com").
+     * @param dnsNames - An array of DNS names that should be associated with this certificate. This is useful for certificates
+     *                   that need to be valid for multiple hostnames.
+     * @param actionType - Optional. Specifies the action to be performed with the certificate, such as 'create' or 'renew'.
+     * @param daysBeforeExpiry - Optional. Number of days before expiry when an action should be taken, useful for auto-renewal scenarios.
+     * @returns A KeyVaultCertificate object representing the newly created self-signed certificate.
+     *
+     * Example usage:
+     * ```typescript
+     * const myCertificate = vault.addSelfSignedCert(
+     *   'myCert',
+     *   'CN=mydomain.com',
+     *   ['mydomain.com', 'www.mydomain.com'],
+     *   'create',
+     *   30
+     * );
+     * ```
+     * This method returns the KeyVaultCertificate object, enabling it to be used immediately within the application or stored for future use.
+     */
+    addSelfSignedCert(certName, subject, dnsNames, actionType, daysBeforeExpiry) {
+        const keyProps = {
+            keyVaultId: this,
+            name: certName,
+            subject: subject,
+            dnsNames: dnsNames,
+            actionType: actionType,
+            daysBeforeExpiry: daysBeforeExpiry,
+            accessPolicies: this.accessPolicies,
+        };
+        const cert = new certificate_1.SelfSignedCertificate(this, certName, keyProps);
+        return cert.certificate;
+    }
+    /**
+     * Adds a certificate issuer to the Azure Key Vault.
+     *
+     * This method configures a certificate issuer within the Key Vault, allowing the Key Vault to issue certificates
+     * through external providers. Configuring an issuer is essential for enabling automated certificate management
+     * processes, such as issuance and renewal, directly through the Key Vault with a specified Certificate Authority (CA).
+     *
+     * @param name - The unique name for the certificate issuer within the Key Vault.
+     * @param provider - The name of the external provider that will issue the certificates, such as 'DigiCert' or 'GlobalSign'.
+     *
+     * Example usage:
+     * ```typescript
+     * vault.addCertIssuer(
+     *   'myCertIssuer',
+     *   'DigiCert'
+     * );
+     * ```
+     * This method configures a certificate issuer but does not return any value. The issuer details, including provider name
+     * and any necessary credentials (managed externally or through additional method parameters), are set up in the Key Vault
+     * for future certificate operations.
+     */
+    addCertIssuer(name, provider) {
+        new certificate_1.CertificateIssuer(this, name, {
+            name: name,
+            providerName: provider,
+            keyVaultId: this,
+            accessPolicies: this.accessPolicies,
+        });
+    }
+}
+exports.Vault = Vault;
+_a = JSII_RTTI_SYMBOL_1;
+Vault[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_keyvault.Vault", version: "0.0.3-pre.10" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vault.js","sourceRoot":"","sources":["../../../src/azure-keyvault/lib/vault.ts"],"names":[],"mappings":";;;;;AAAA,qEAG+C;AAK/C,+BAA+B;AAE/B,+CAIuB;AACvB,+BAAsC;AACtC,qCAA2D;AAC3D,qCAA+C;AAC/C,8CAAqD;AA4ErD,MAAa,KAAM,SAAQ,mBAAa;IAOtC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAiB;QACzD,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QA7BX,mBAAc,GAAmB,EAAE,CAAC;QA+B1C,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC;QAEzC,yBAAyB;QACzB,MAAM,eAAe,GAAG,KAAK,CAAC,eAAe,IAAI,IAAI,CAAC;QACtD,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,IAAI,UAAU,CAAC;QACpC,MAAM,uBAAuB,GAAG,KAAK,CAAC,uBAAuB,IAAI,EAAE,CAAC;QAEpE,MAAM,eAAe,GAAG,IAAI,oBAAQ,CAAC,IAAI,EAAE,WAAW,EAAE;YACtD,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,iBAAiB,EAAE,KAAK,CAAC,aAAa,CAAC,IAAI;YAC3C,IAAI,EAAE,KAAK,CAAC,IAAI;YAChB,OAAO,EAAE,GAAG;YACZ,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,sBAAsB,EAAE,eAAe;YACvC,uBAAuB,EAAE,uBAAuB;SACjD,CAAC,CAAC;QACH,IAAI,CAAC,EAAE,GAAG,eAAe,CAAC,EAAE,CAAC;QAC7B,IAAI,CAAC,QAAQ,GAAG,eAAe,CAAC;QAEhC,oBAAoB;QACpB,MAAM,8BAA8B,GAAG,IAAI,KAAK,CAAC,eAAe,CAC9D,IAAI,EACJ,IAAI,EACJ;YACE,KAAK,EAAE,eAAe,CAAC,EAAE;SAC1B,CACF,CAAC;QAEF,gIAAgI;QAChI,8BAA8B,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QAEvD,MAAM,gCAAgC,GAAG,IAAI,KAAK,CAAC,eAAe,CAChE,IAAI,EACJ,gBAAgB,EAChB;YACE,KAAK,EAAE,eAAe,CAAC,IAAI;SAC5B,CACF,CAAC;QAEF,gIAAgI;QAChI,gCAAgC,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,CAAC;IACvE,CAAC;IAED;;;;OAIG;IACI,uBAAuB,CAAC,cAAsB;QACnD,MAAM,WAAW,GAAsB;YACrC,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ;YAC7B,QAAQ,EAAE,cAAc;YACxB,iBAAiB,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC;SACnC,CAAC;QAEF,MAAM,MAAM,GAAG,IAAI,qBAAY,CAC7B,IAAI,EACJ,2BAA2B,cAAc,EAAE,EAC3C,WAAW,CACZ,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED;;;;OAIG;IACI,sBAAsB,CAAC,cAAsB;QAClD,MAAM,WAAW,GAAsB;YACrC,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ;YAC7B,QAAQ,EAAE,cAAc;YACxB,iBAAiB,EAAE;gBACjB,KAAK;gBACL,MAAM;gBACN,KAAK;gBACL,QAAQ;gBACR,QAAQ;gBACR,SAAS;gBACT,SAAS;aACV;SACF,CAAC;QAEF,MAAM,MAAM,GAAG,IAAI,qBAAY,CAC7B,IAAI,EACJ,0BAA0B,cAAc,EAAE,EAC1C,WAAW,CACZ,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED;;;;OAIG;IACI,oBAAoB,CAAC,cAAsB;QAChD,MAAM,WAAW,GAAsB;YACrC,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ;YAC7B,QAAQ,EAAE,cAAc;YACxB,sBAAsB,EAAE;gBACtB,KAAK;gBACL,MAAM;gBACN,KAAK;gBACL,QAAQ;gBACR,QAAQ;gBACR,SAAS;gBACT,SAAS;aACV;SACF,CAAC;QAEF,MAAM,MAAM,GAAG,IAAI,qBAAY,CAC7B,IAAI,EACJ,wBAAwB,cAAc,EAAE,EACxC,WAAW,CACZ,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED;;;;OAIG;IACI,qBAAqB,CAAC,cAAsB;QACjD,MAAM,WAAW,GAAsB;YACrC,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ;YAC7B,QAAQ,EAAE,cAAc;YACxB,sBAAsB,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC;SACxC,CAAC;QAEF,MAAM,MAAM,GAAG,IAAI,qBAAY,CAC7B,IAAI,EACJ,yBAAyB,cAAc,EAAE,EACzC,WAAW,CACZ,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED;;;;OAIG;IACI,mBAAmB,CAAC,cAAsB;QAC/C,MAAM,WAAW,GAAsB;YACrC,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ;YAC7B,QAAQ,EAAE,cAAc;YACxB,cAAc,EAAE;gBACd,KAAK;gBACL,MAAM;gBACN,KAAK;gBACL,QAAQ;gBACR,QAAQ;gBACR,SAAS;gBACT,SAAS;aACV;SACF,CAAC;QAEF,MAAM,MAAM,GAAG,IAAI,qBAAY,CAC7B,IAAI,EACJ,uBAAuB,cAAc,EAAE,EACvC,WAAW,CACZ,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED;;;;OAIG;IACI,oBAAoB,CAAC,cAAsB;QAChD,MAAM,WAAW,GAAsB;YACrC,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ;YAC7B,QAAQ,EAAE,cAAc;YACxB,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC;SAChC,CAAC;QAEF,MAAM,MAAM,GAAG,IAAI,qBAAY,CAC7B,IAAI,EACJ,wBAAwB,cAAc,EAAE,EACxC,WAAW,CACZ,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED;;;;;OAKG;IACI,iBAAiB,CACtB,cAAsB,EACtB,OAAiC;QAEjC,MAAM,WAAW,GAAsB;YACrC,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,QAAQ;YAC7B,QAAQ,EAAE,cAAc;YACxB,GAAG,OAAO;SACX,CAAC;QAEF,MAAM,MAAM,GAAG,IAAI,qBAAY,CAC7B,IAAI,EACJ,2BAA2B,cAAc,EAAE,EAC3C,WAAW,CACZ,CAAC;QACF,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACI,SAAS,CACd,kBAA0B,EAC1B,WAAmB,EACnB,cAAuB,EACvB,WAAoB;QAEpB,MAAM,WAAW,GAAgB;YAC/B,UAAU,EAAE,IAAI;YAChB,IAAI,EAAE,kBAAkB;YACxB,KAAK,EAAE,WAAW;YAClB,cAAc,EAAE,cAAc;YAC9B,WAAW,EAAE,WAAW;YACxB,cAAc,EAAE,IAAI,CAAC,cAAc;SACpC,CAAC;QAEF,IAAI,eAAM,CAAC,IAAI,EAAE,kBAAkB,EAAE,WAAW,CAAC,CAAC;IACpD,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACI,SAAS,CACd,eAAuB,EACvB,cAAuB;QAEvB,MAAM,QAAQ,GAAa;YACzB,UAAU,EAAE,IAAI;YAChB,IAAI,EAAE,eAAe;YACrB,OAAO,EAAE,KAAK;YACd,OAAO,EAAE,IAAI;YACb,OAAO,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,CAAC;YACzE,OAAO,EAAE,cAAc;YACvB,cAAc,EAAE,IAAI,CAAC,cAAc;SACpC,CAAC;QAEF,MAAM,GAAG,GAAG,IAAI,SAAG,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,CAAC,CAAC;QACrD,OAAO,GAAG,CAAC,QAAQ,CAAC;IACtB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACI,MAAM,CACX,eAAuB,EACvB,OAAe,EACf,OAAe,EACf,OAAiB,EACjB,cAAuB;QAEvB,MAAM,QAAQ,GAAa;YACzB,UAAU,EAAE,IAAI;YAChB,IAAI,EAAE,eAAe;YACrB,OAAO,EAAE,OAAO;YAChB,OAAO,EAAE,OAAO;YAChB,OAAO,EAAE,OAAO;YAChB,OAAO,EAAE,cAAc;YACvB,cAAc,EAAE,IAAI,CAAC,cAAc;SACpC,CAAC;QAEF,MAAM,GAAG,GAAG,IAAI,SAAG,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,CAAC,CAAC;QACrD,OAAO,GAAG,CAAC,QAAQ,CAAC;IACtB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACI,iBAAiB,CACtB,QAAgB,EAChB,OAAe,EACf,QAAkB,EAClB,UAAmB,EACnB,gBAAyB;QAEzB,MAAM,QAAQ,GAA+B;YAC3C,UAAU,EAAE,IAAI;YAChB,IAAI,EAAE,QAAQ;YACd,OAAO,EAAE,OAAO;YAChB,QAAQ,EAAE,QAAQ;YAClB,UAAU,EAAE,UAAU;YACtB,gBAAgB,EAAE,gBAAgB;YAClC,cAAc,EAAE,IAAI,CAAC,cAAc;SACpC,CAAC;QACF,MAAM,IAAI,GAAG,IAAI,mCAAqB,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;QACjE,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACI,aAAa,CAAC,IAAY,EAAE,QAAgB;QACjD,IAAI,+BAAiB,CAAC,IAAI,EAAE,IAAI,EAAE;YAChC,IAAI,EAAE,IAAI;YACV,YAAY,EAAE,QAAQ;YACtB,UAAU,EAAE,IAAI;YAChB,cAAc,EAAE,IAAI,CAAC,cAAc;SACpC,CAAC,CAAC;IACL,CAAC;;AAndH,sBAodC","sourcesContent":["import {\n  KeyVault,\n  KeyVaultNetworkAcls,\n} from \"@cdktf/provider-azurerm/lib/key-vault\";\nimport { KeyVaultCertificate } from \"@cdktf/provider-azurerm/lib/key-vault-certificate\"; // Adjust the import path based on the actual module location.\nimport { KeyVaultKey } from \"@cdktf/provider-azurerm/lib/key-vault-key\";\nimport { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\n\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  CertificateIssuer,\n  SelfSignedCertificate,\n  SelfSignedCertificateProps,\n} from \"./certificate\";\nimport { Key, KeyProps } from \"./key\";\nimport { AccessPolicy, AccessPolicyProps } from \"./policy\";\nimport { Secret, SecretProps } from \"./secret\";\nimport { AzureResource } from \"../../core-azure/lib\";\n\nexport interface VaultProps {\n  /**\n   * The name of the Key Vault.\n   */\n  readonly name: string;\n  /**\n   * The Azure Region to deploy the Key Vault.\n   */\n  readonly location: string;\n  /**\n   * The name of the Azure Resource Group.\n   */\n  readonly resourceGroup: ResourceGroup;\n  /**\n   * The tags to assign to the Key Vault.\n   */\n  readonly tags?: { [key: string]: string };\n  /**\n   * The tags to assign to the Key Vault.\n   */\n  readonly sku?: string;\n  /**\n   * The Name of the SKU used for this Key Vault. Possible values are standard and premium.\n   */\n  readonly tenantId: string;\n  /**\n   * The Azure Active Directory tenant ID that should be used for authenticating requests to the key vault.\n   */\n  readonly networkAcls?: KeyVaultNetworkAcls;\n  /**\n   * A map of IP network ACL rules. The key is the IP or IP range in CIDR notation.\n   * The value is a description of that IP range.\n   */\n  readonly purgeProtection?: boolean;\n  /**\n   *  Specifies whether protection against purge is enabled for this Key Vault.\n   * Setting this property to true activates protection against deletion of any active key, secret or certificate in the vault. The setting is effective only if soft delete is also enabled. The default value is false.\n   * Once activated, the property cannot be reverted to false.\n   */\n  readonly softDeleteRetentionDays?: number;\n  /**\n   * The number of days that items should be retained for once soft-deleted.\n   */\n}\n\n/**\n * Options for granting custom access permissions in Azure Key Vault.\n */\nexport interface GrantCustomAccessOptions {\n  /**\n   * Optional: A list of permissions to grant for secrets in the Key Vault.\n   * Example permissions include 'get', 'list', 'set', 'delete', etc.\n   */\n  readonly secretPermissions?: string[];\n\n  /**\n   * Optional: A list of permissions to grant for certificates in the Key Vault.\n   * Example permissions include 'get', 'list', 'create', 'delete', etc.\n   */\n  readonly certificatePermissions?: string[];\n\n  /**\n   * Optional: A list of permissions to grant for keys in the Key Vault.\n   * Example permissions include 'encrypt', 'decrypt', 'wrapKey', 'unwrapKey', etc.\n   */\n  readonly keyPermissions?: string[];\n\n  /**\n   * Optional: A list of permissions to grant for storage accounts in the Key Vault.\n   * Example permissions include 'get', 'list', 'delete', 'set', 'update', etc.\n   */\n  readonly storagePermissions?: string[];\n}\n\nexport class Vault extends AzureResource {\n  readonly props: VaultProps;\n  public keyVault: KeyVault;\n  public resourceGroup: ResourceGroup;\n  public id: string;\n  private accessPolicies: AccessPolicy[] = [];\n\n  /**\n   * Constructs a new Azure Key Vault resource.\n   *\n   * This class creates and configures an Azure Key Vault, a secure store for managing secrets, keys, certificates, and other sensitive data.\n   * It supports advanced configurations such as access policies, network rules, and data retention policies.\n   *\n   * @param scope - The scope in which to define this construct, usually representing the Cloud Development Kit (CDK) stack.\n   * @param id - The unique identifier for this instance of the Key Vault.\n   * @param props - The properties for creating the Key Vault as defined in VaultProps. These include settings for location, SKU, tenant ID, etc.\n   *\n   * Example usage:\n   * ```typescript\n   * new Vault(this, 'MyKeyVault', {\n   *   name: 'mySecureVault',\n   *   location: 'East US',\n   *   resourceGroup: myResourceGroup,\n   *   sku: 'premium',\n   *   tenantId: 'my-tenant-id',\n   *   softDeleteRetentionDays: 90,\n   *   purgeProtection: true,\n   *   tags: {\n   *     project: 'My Application'\n   *   }\n   * });\n   * ```\n   */\n  constructor(scope: Construct, id: string, props: VaultProps) {\n    super(scope, id);\n\n    this.props = props;\n    this.resourceGroup = props.resourceGroup;\n\n    // Provide default values\n    const purgeProtection = props.purgeProtection ?? true;\n    const sku = props.sku ?? \"standard\";\n    const softDeleteRetentionDays = props.softDeleteRetentionDays ?? 90;\n\n    const azurermKeyVault = new KeyVault(this, \"key_vault\", {\n      name: props.name,\n      location: props.location,\n      resourceGroupName: props.resourceGroup.name,\n      tags: props.tags,\n      skuName: sku,\n      tenantId: props.tenantId,\n      networkAcls: props.networkAcls,\n      purgeProtectionEnabled: purgeProtection,\n      softDeleteRetentionDays: softDeleteRetentionDays,\n    });\n    this.id = azurermKeyVault.id;\n    this.keyVault = azurermKeyVault;\n\n    // Terraform Outputs\n    const cdktfTerraformOutputKeyVaultid = new cdktf.TerraformOutput(\n      this,\n      \"id\",\n      {\n        value: azurermKeyVault.id,\n      },\n    );\n\n    /*This allows the Terraform resource name to match the original name. You can remove the call if you don't need them to match.*/\n    cdktfTerraformOutputKeyVaultid.overrideLogicalId(\"id\");\n\n    const cdktfTerraformOutputKeyVaultname = new cdktf.TerraformOutput(\n      this,\n      \"key_vault_name\",\n      {\n        value: azurermKeyVault.name,\n      },\n    );\n\n    /*This allows the Terraform resource name to match the original name. You can remove the call if you don't need them to match.*/\n    cdktfTerraformOutputKeyVaultname.overrideLogicalId(\"key_vault_name\");\n  }\n\n  /**\n   * Grants read-only access to secrets stored in the Key Vault to a specified Azure AD group.\n   *\n   * @param azureAdGroupId - The Azure Active Directory group ID that will receive read access to secrets.\n   */\n  public grantSecretReaderAccess(azureAdGroupId: string) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      secretPermissions: [\"Get\", \"List\"],\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_secret_reader_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  /**\n   * Grants administrative access to secrets stored in the Key Vault to a specified Azure AD group.\n   *\n   * @param azureAdGroupId - The Azure Active Directory group ID that will receive administrative access to secrets.\n   */\n  public grantSecretAdminAccess(azureAdGroupId: string) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      secretPermissions: [\n        \"Get\",\n        \"List\",\n        \"Set\",\n        \"Delete\",\n        \"Backup\",\n        \"Restore\",\n        \"Recover\",\n      ],\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_secret_admin_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  /**\n   * Grants administrative access to certificates stored in the Key Vault to a specified Azure AD group.\n   *\n   * @param azureAdGroupId - The Azure Active Directory group ID that will receive administrative access to certificates.\n   */\n  public grantCertAdminAccess(azureAdGroupId: string) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      certificatePermissions: [\n        \"Get\",\n        \"List\",\n        \"Set\",\n        \"Delete\",\n        \"Backup\",\n        \"Restore\",\n        \"Recover\",\n      ],\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_cert_admin_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  /**\n   * Grants read-only access to certificates stored in the Key Vault to a specified Azure AD group.\n   *\n   * @param azureAdGroupId - The Azure Active Directory group ID that will receive read access to certificates.\n   */\n  public grantCertReaderAccess(azureAdGroupId: string) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      certificatePermissions: [\"Get\", \"List\"],\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_cert_reader_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  /**\n   * Grants administrative access to keys stored in the Key Vault to a specified Azure AD group.\n   *\n   * @param azureAdGroupId - The Azure Active Directory group ID that will receive administrative access to keys.\n   */\n  public grantKeyAdminAccess(azureAdGroupId: string) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      keyPermissions: [\n        \"Get\",\n        \"List\",\n        \"Set\",\n        \"Delete\",\n        \"Backup\",\n        \"Restore\",\n        \"Recover\",\n      ],\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_key_admin_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  /**\n   * Grants read-only access to keys stored in the Key Vault to a specified Azure AD group.\n   *\n   * @param azureAdGroupId - The Azure Active Directory group ID that will receive read access to keys.\n   */\n  public grantKeyReaderAccess(azureAdGroupId: string) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      keyPermissions: [\"Get\", \"List\"],\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_key_reader_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  /**\n   * Grants custom access based on specified options to an Azure AD group in the Key Vault.\n   *\n   * @param azureAdGroupId - The Azure Active Directory group ID that will receive the custom access.\n   * @param options - Custom access options specifying various permissions for secrets, keys, certificates, and storage.\n   */\n  public grantCustomAccess(\n    azureAdGroupId: string,\n    options: GrantCustomAccessOptions,\n  ) {\n    const policyProps: AccessPolicyProps = {\n      keyVaultId: this,\n      tenantId: this.props.tenantId,\n      objectId: azureAdGroupId,\n      ...options,\n    };\n\n    const policy = new AccessPolicy(\n      this,\n      `kv_custom_policy_access_${azureAdGroupId}`,\n      policyProps,\n    );\n    this.accessPolicies.push(policy);\n  }\n\n  /**\n   * Creates a new secret within the Azure Key Vault.\n   *\n   * This method facilitates the storage of sensitive information in the form of a secret within the Key Vault.\n   * Secrets are protected items such as passwords, database connection strings, or any other piece of information\n   * that needs to be securely stored and accessed. This method allows setting additional properties such as\n   * expiration date and content type for better management and compliance.\n   *\n   * @param keyVaultSecretName - The unique name for the secret within the Key Vault.\n   * @param secretValue - The sensitive information or data that needs to be securely stored as a secret.\n   * @param expirationDate - Optional. The expiration date of the secret in ISO 8601 format (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SSZ).\n   *                         If provided, the secret will no longer be valid after this date.\n   * @param contentType - Optional. A description of the type of information the secret contains (e.g., 'password', 'connectionString').\n   *                      This can be used by applications to handle the secret appropriately.\n   *\n   * Example usage:\n   * ```typescript\n   * vault.addSecret(\n   *   'myDatabasePassword',\n   *   'p@ssw0rd123!',\n   *   '2030-01-01',\n   *   'databasePassword'\n   * );\n   * ```\n   * This method does not return a value. It creates a secret within the Key Vault with the specified properties.\n   */\n  public addSecret(\n    keyVaultSecretName: string,\n    secretValue: string,\n    expirationDate?: string,\n    contentType?: string,\n  ) {\n    const secretProps: SecretProps = {\n      keyVaultId: this,\n      name: keyVaultSecretName,\n      value: secretValue,\n      expirationDate: expirationDate,\n      contentType: contentType,\n      accessPolicies: this.accessPolicies,\n    };\n\n    new Secret(this, keyVaultSecretName, secretProps);\n  }\n\n  /**\n   * Creates an RSA cryptographic key within the Azure Key Vault.\n   *\n   * This method facilitates the creation of an RSA key, which is useful for a variety of cryptographic operations such as\n   * encryption, decryption, digital signature verification, and more. The RSA key created by this method is configurable\n   * with an optional expiration date and a default key size of 2048 bits. The key operations allowed include decryption,\n   * encryption, signing, verifying signatures, and key wrapping/unwrapping.\n   *\n   * @param keyVaultKeyName - The unique name for the RSA key within the Key Vault.\n   * @param expirationDate - Optional. The expiration date of the key in ISO 8601 format (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SSZ).\n   *                         If provided, the key will no longer be valid after this date.\n   * @returns A KeyVaultKey object representing the newly created RSA key within the vault.\n   *\n   * Example usage:\n   * ```typescript\n   * const rsaKey = vault.addRSAKey(\n   *   'myRSAKey',\n   *   '2030-01-01'\n   * );\n   * ```\n   * This method returns the created KeyVaultKey object, allowing further operations or references to the key.\n   */\n  public addRSAKey(\n    keyVaultKeyName: string,\n    expirationDate?: string,\n  ): KeyVaultKey {\n    const keyProps: KeyProps = {\n      keyVaultId: this,\n      name: keyVaultKeyName,\n      keyType: \"RSA\",\n      keySize: 2048,\n      keyOpts: [\"decrypt\", \"encrypt\", \"sign\", \"unwrapKey\", \"verify\", \"wrapKey\"],\n      expires: expirationDate,\n      accessPolicies: this.accessPolicies,\n    };\n\n    const key = new Key(this, keyVaultKeyName, keyProps);\n    return key.vaultKey;\n  }\n\n  /**\n   * Creates a cryptographic key within the Azure Key Vault.\n   *\n   * This method allows the creation of a cryptographic key of specified type and size within the Key Vault. The key can be\n   * configured with specific operations it can perform, such as encryption, decryption, signing, etc. An optional expiration\n   * date can also be set to control the key's lifecycle. This method is flexible, supporting various key types and sizes,\n   * making it suitable for a wide range of cryptographic needs.\n   *\n   * @param keyVaultKeyName - The unique name for the cryptographic key within the Key Vault.\n   * @param keyType - The type of cryptographic key to create (e.g., 'RSA', 'EC', 'oct-HSM').\n   * @param keySize - The size of the cryptographic key in bits (e.g., 2048, 3072, 4096 for RSA).\n   * @param keyOpts - A list of cryptographic operations that the key is allowed to perform. Possible values might include\n   *                  'encrypt', 'decrypt', 'sign', 'verify', 'wrapKey', 'unwrapKey'.\n   * @param expirationDate - Optional. The expiration date of the key in ISO 8601 format (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SSZ).\n   *                         If provided, the key will no longer be valid after this date, aligning with best practices for key management.\n   * @returns A KeyVaultKey object representing the newly created cryptographic key within the vault.\n   *\n   * Example usage:\n   * ```typescript\n   * const myKey = vault.addKey(\n   *   'myKey',\n   *   'RSA',\n   *   2048,\n   *   ['encrypt', 'decrypt', 'sign', 'verify'],\n   *   '2030-12-31'\n   * );\n   * ```\n   * This method returns the created KeyVaultKey object, enabling immediate use within the application for cryptographic operations.\n   */\n  public addKey(\n    keyVaultKeyName: string,\n    keyType: string,\n    keySize: number,\n    keyOpts: string[],\n    expirationDate?: string,\n  ): KeyVaultKey {\n    const keyProps: KeyProps = {\n      keyVaultId: this,\n      name: keyVaultKeyName,\n      keyType: keyType,\n      keySize: keySize,\n      keyOpts: keyOpts,\n      expires: expirationDate,\n      accessPolicies: this.accessPolicies,\n    };\n\n    const key = new Key(this, keyVaultKeyName, keyProps);\n    return key.vaultKey;\n  }\n\n  /**\n   * Creates a self-signed certificate within the Azure Key Vault.\n   *\n   * This method facilitates the creation of a self-signed certificate, which is a digital certificate that is signed by\n   * its own creator rather than a trusted authority. Self-signed certificates can be useful for testing, internal\n   * communications, or any scenario where public trust is not required. The method allows specifying subject details,\n   * DNS names for the certificate, and managing its lifecycle with action types and expiry.\n   *\n   * @param certName - The unique name for the certificate within the Key Vault.\n   * @param subject - The subject name of the certificate, typically formatted as an X.500 Distinguished Name (e.g., \"CN=example.com\").\n   * @param dnsNames - An array of DNS names that should be associated with this certificate. This is useful for certificates\n   *                   that need to be valid for multiple hostnames.\n   * @param actionType - Optional. Specifies the action to be performed with the certificate, such as 'create' or 'renew'.\n   * @param daysBeforeExpiry - Optional. Number of days before expiry when an action should be taken, useful for auto-renewal scenarios.\n   * @returns A KeyVaultCertificate object representing the newly created self-signed certificate.\n   *\n   * Example usage:\n   * ```typescript\n   * const myCertificate = vault.addSelfSignedCert(\n   *   'myCert',\n   *   'CN=mydomain.com',\n   *   ['mydomain.com', 'www.mydomain.com'],\n   *   'create',\n   *   30\n   * );\n   * ```\n   * This method returns the KeyVaultCertificate object, enabling it to be used immediately within the application or stored for future use.\n   */\n  public addSelfSignedCert(\n    certName: string,\n    subject: string,\n    dnsNames: string[],\n    actionType?: string,\n    daysBeforeExpiry?: number,\n  ): KeyVaultCertificate {\n    const keyProps: SelfSignedCertificateProps = {\n      keyVaultId: this,\n      name: certName,\n      subject: subject,\n      dnsNames: dnsNames,\n      actionType: actionType,\n      daysBeforeExpiry: daysBeforeExpiry,\n      accessPolicies: this.accessPolicies,\n    };\n    const cert = new SelfSignedCertificate(this, certName, keyProps);\n    return cert.certificate;\n  }\n\n  /**\n   * Adds a certificate issuer to the Azure Key Vault.\n   *\n   * This method configures a certificate issuer within the Key Vault, allowing the Key Vault to issue certificates\n   * through external providers. Configuring an issuer is essential for enabling automated certificate management\n   * processes, such as issuance and renewal, directly through the Key Vault with a specified Certificate Authority (CA).\n   *\n   * @param name - The unique name for the certificate issuer within the Key Vault.\n   * @param provider - The name of the external provider that will issue the certificates, such as 'DigiCert' or 'GlobalSign'.\n   *\n   * Example usage:\n   * ```typescript\n   * vault.addCertIssuer(\n   *   'myCertIssuer',\n   *   'DigiCert'\n   * );\n   * ```\n   * This method configures a certificate issuer but does not return any value. The issuer details, including provider name\n   * and any necessary credentials (managed externally or through additional method parameters), are set up in the Key Vault\n   * for future certificate operations.\n   */\n  public addCertIssuer(name: string, provider: string) {\n    new CertificateIssuer(this, name, {\n      name: name,\n      providerName: provider,\n      keyVaultId: this,\n      accessPolicies: this.accessPolicies,\n    });\n  }\n}\n"]}

package/lib/azure-keyvault/test/AzureKeyVault.spec.d.ts

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

package/lib/azure-keyvault/test/AzureKeyVault.spec.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const provider_1 = require("@cdktf/provider-azurerm/lib/provider");
+const resource_group_1 = require("@cdktf/provider-azurerm/lib/resource-group");
+const cdktf_1 = require("cdktf");
+const ExampleAzureKeyVault_1 = require("./ExampleAzureKeyVault");
+require("cdktf/lib/testing/adapters/jest");
+const kv = require("..");
+const util = require("../../util/azureTenantIdHelpers");
+describe("Azure Key Vault 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: {} });
+        const rg = new resource_group_1.ResourceGroup(stack, "MyResourceGroup", {
+            name: "rg-test",
+            location: "eastus",
+        });
+        new kv.Vault(stack, "testAzureKeyVaultDefaults", {
+            name: "kv-test",
+            location: "eastus",
+            resourceGroup: rg,
+            tenantId: "123e4567-e89b-12d3-a456-426614174000",
+        });
+        fullSynthResult = cdktf_1.Testing.fullSynth(stack); // Save the result for reuse
+    });
+    it("renders an Azure Key Vault 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("Azure Key Vault Example", () => {
+    //let stack: TerraformStack;
+    // beforeEach(() => {
+    //   const app = Testing.app();
+    //   stack = new TerraformStack(app, "test");
+    //   Testing.synthScope((stack) => {
+    //     new exampleAzureKeyVault(stack, "testAzureKeyVault");
+    //   });
+    // });
+    it("renders the Example Azure KeyVault 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 ExampleAzureKeyVault_1.exampleAzureKeyVault(cdktf_1.Testing.app(), "testAzureKeyVault"));
+        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 ExampleAzureKeyVault_1.exampleAzureKeyVault(cdktf_1.Testing.app(), "testAzureKeyVault"))).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 ExampleAzureKeyVault_1.exampleAzureKeyVault(cdktf_1.Testing.app(), "testAzureKeyVault"))).toPlanSuccessfully();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/azure-keyvault/test/ExampleAzureKeyVault.d.ts

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