resource/aws_comprehend_document_classifier: New resource

internal/provider/provider.go

@@ -1177,7 +1177,8 @@ func New(_ context.Context) (*schema.Provider, error) {
 			"aws_cognito_user_pool_domain":           cognitoidp.ResourceUserPoolDomain(),
 			"aws_cognito_user_pool_ui_customization": cognitoidp.ResourceUserPoolUICustomization(),
 
-			"aws_comprehend_entity_recognizer": comprehend.ResourceEntityRecognizer(),
+			"aws_comprehend_document_classifier": comprehend.ResourceDocumentClassifier(),
+			"aws_comprehend_entity_recognizer":   comprehend.ResourceEntityRecognizer(),
 
 			"aws_config_aggregate_authorization":       configservice.ResourceAggregateAuthorization(),
 			"aws_config_config_rule":                   configservice.ResourceConfigRule(),

internal/service/comprehend/acc_test.go

@@ -6,6 +6,7 @@ import (
 	"testing"
 
 	"github.com/aws/aws-sdk-go-v2/service/comprehend"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
 	"github.com/hashicorp/terraform-provider-aws/internal/acctest"
 	"github.com/hashicorp/terraform-provider-aws/internal/conns"
 )
@@ -56,3 +57,11 @@ resource "aws_subnet" "test" {
 `, rName, subnetCount),
 	)
 }
+
+func uniqueIDPattern() string {
+	return prefixedUniqueIDPattern(resource.UniqueIdPrefix)
+}
+
+func prefixedUniqueIDPattern(prefix string) string {
+	return fmt.Sprintf("%s[[:xdigit:]]{%d}", prefix, resource.UniqueIDSuffixLength)
+}

internal/service/comprehend/common_model.go

@@ -7,8 +7,11 @@ import (
 	"time"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/comprehend/types"
 	"github.com/aws/aws-sdk-go/service/ec2"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/hashicorp/terraform-provider-aws/internal/flex"
 	tfec2 "github.com/hashicorp/terraform-provider-aws/internal/service/ec2"
 )
 
@@ -93,3 +96,121 @@ func statusNetworkInterfaces(ctx context.Context, conn *ec2.EC2, initialENIs map
 		return added, aws.ToString(added.Status), nil
 	}
 }
+
+type resourceGetter interface {
+	Get(key string) any
+}
+
+func flattenVPCConfig(apiObject *types.VpcConfig) []interface{} {
+	if apiObject == nil {
+		return nil
+	}
+
+	m := map[string]interface{}{
+		"security_group_ids": flex.FlattenStringValueSet(apiObject.SecurityGroupIds),
+		"subnets":            flex.FlattenStringValueSet(apiObject.Subnets),
+	}
+
+	return []interface{}{m}
+}
+
+func expandVPCConfig(tfList []interface{}) *types.VpcConfig {
+	if len(tfList) == 0 {
+		return nil
+	}
+
+	tfMap := tfList[0].(map[string]interface{})
+
+	a := &types.VpcConfig{
+		SecurityGroupIds: flex.ExpandStringValueSet(tfMap["security_group_ids"].(*schema.Set)),
+		Subnets:          flex.ExpandStringValueSet(tfMap["subnets"].(*schema.Set)),
+	}
+
+	return a
+}
+
+func flattenAugmentedManifests(apiObjects []types.AugmentedManifestsListItem) []interface{} {
+	if len(apiObjects) == 0 {
+		return nil
+	}
+
+	var l []interface{}
+
+	for _, apiObject := range apiObjects {
+		l = append(l, flattenAugmentedManifestsListItem(&apiObject))
+	}
+
+	return l
+}
+
+func flattenAugmentedManifestsListItem(apiObject *types.AugmentedManifestsListItem) map[string]interface{} {
+	if apiObject == nil {
+		return nil
+	}
+
+	m := map[string]interface{}{
+		"attribute_names": flex.FlattenStringValueList(apiObject.AttributeNames),
+		"s3_uri":          aws.ToString(apiObject.S3Uri),
+		"document_type":   apiObject.DocumentType,
+		"split":           apiObject.Split,
+	}
+
+	if v := apiObject.AnnotationDataS3Uri; v != nil {
+		m["annotation_data_s3_uri"] = aws.ToString(v)
+	}
+
+	if v := apiObject.SourceDocumentsS3Uri; v != nil {
+		m["source_documents_s3_uri"] = aws.ToString(v)
+	}
+
+	return m
+}
+
+func expandAugmentedManifests(tfSet *schema.Set) []types.AugmentedManifestsListItem {
+	if tfSet.Len() == 0 {
+		return nil
+	}
+
+	var s []types.AugmentedManifestsListItem
+
+	for _, r := range tfSet.List() {
+		m, ok := r.(map[string]interface{})
+
+		if !ok {
+			continue
+		}
+
+		a := expandAugmentedManifestsListItem(m)
+
+		if a == nil {
+			continue
+		}
+
+		s = append(s, *a)
+	}
+
+	return s
+}
+
+func expandAugmentedManifestsListItem(tfMap map[string]interface{}) *types.AugmentedManifestsListItem {
+	if tfMap == nil {
+		return nil
+	}
+
+	a := &types.AugmentedManifestsListItem{
+		AttributeNames: flex.ExpandStringValueList(tfMap["attribute_names"].([]interface{})),
+		S3Uri:          aws.String(tfMap["s3_uri"].(string)),
+		DocumentType:   types.AugmentedManifestsDocumentTypeFormat(tfMap["document_type"].(string)),
+		Split:          types.Split(tfMap["split"].(string)),
+	}
+
+	if v, ok := tfMap["annotation_data_s3_uri"].(string); ok && v != "" {
+		a.AnnotationDataS3Uri = aws.String(v)
+	}
+
+	if v, ok := tfMap["source_documents_s3_uri"].(string); ok && v != "" {
+		a.SourceDocumentsS3Uri = aws.String(v)
+	}
+
+	return a
+}

internal/service/comprehend/consts.go

@@ -7,5 +7,12 @@ import (
 const iamPropagationTimeout = 2 * time.Minute
 
 // Avoid service throttling
-const entityRegcognizerDelay = 1 * time.Minute
+const entityRegcognizerCreatedDelay = 10 * time.Minute
+const entityRegcognizerStoppedDelay = 0
+const entityRegcognizerDeletedDelay = 5 * time.Minute
 const entityRegcognizerPollInterval = 1 * time.Minute
+
+const documentClassifierCreatedDelay = 15 * time.Minute
+const documentClassifierStoppedDelay = 0
+const documentClassifierDeletedDelay = 5 * time.Minute
+const documentClassifierPollInterval = 1 * time.Minute

internal/service/comprehend/diff.go

@@ -2,13 +2,15 @@ package comprehend
 
 import (
 	"regexp"
+	"strings"
 
 	"github.com/aws/aws-sdk-go-v2/aws/arn"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	tfkms "github.com/hashicorp/terraform-provider-aws/internal/service/kms"
 	"github.com/hashicorp/terraform-provider-aws/internal/verify"
 )
 
-func diffSuppressKMSKeyId(k, oldValue, newValue string, d *schema.ResourceData) bool {
+func diffSuppressKMSKeyId(_, oldValue, newValue string, _ *schema.ResourceData) bool {
 	if oldValue == newValue {
 		return true
 	}
@@ -30,6 +32,41 @@ func diffSuppressKMSKeyId(k, oldValue, newValue string, d *schema.ResourceData)
 	return false
 }
 
+func diffSuppressKMSAlias(_, oldValue, newValue string, _ *schema.ResourceData) bool {
+	if oldValue == newValue {
+		return true
+	}
+
+	oldAlias := oldValue
+	if arn.IsARN(oldValue) {
+		oldAlias = kmsKeyAliasFromARN(oldValue)
+	}
+
+	newAlias := newValue
+	if arn.IsARN(newValue) {
+		newAlias = kmsKeyAliasFromARN(newValue)
+	}
+
+	if oldAlias == newAlias {
+		return true
+	}
+
+	return false
+}
+
+func diffSuppressKMSKeyOrAlias(k, oldValue, newValue string, d *schema.ResourceData) bool {
+	if arn.IsARN(newValue) {
+		if isKMSKeyARN(newValue) {
+			return diffSuppressKMSKeyId(k, oldValue, newValue, d)
+		} else {
+			return diffSuppressKMSAlias(k, oldValue, newValue, d)
+		}
+	} else if isKMSAliasName(newValue) {
+		return diffSuppressKMSAlias(k, oldValue, newValue, d)
+	}
+	return diffSuppressKMSKeyId(k, oldValue, newValue, d)
+}
+
 func kmsKeyIdFromARN(s string) string {
 	arn, err := arn.Parse(s)
 	if err != nil {
@@ -47,5 +84,44 @@ func kmsKeyIdFromARNResource(s string) string {
 	}
 
 	return matches[1]
+}
+
+func kmsKeyAliasFromARN(s string) string {
+	arn, err := arn.Parse(s)
+	if err != nil {
+		return ""
+	}
+
+	return kmsKeyAliasNameFromARNResource(arn.Resource)
+}
+
+func kmsKeyAliasNameFromARNResource(s string) string {
+	re := regexp.MustCompile("^" + tfkms.AliasNameRegexPattern + "$")
+	if re.MatchString(s) {
+		return s
+	}
+
+	return ""
+}
+
+func isKMSKeyARN(s string) bool {
+	parsedARN, err := arn.Parse(s)
+	if err != nil {
+		return false
+	}
+
+	return kmsKeyIdFromARNResource(parsedARN.Resource) != ""
+}
+
+func isKMSAliasName(s string) bool {
+	return strings.HasPrefix(s, "alias/")
+}
+
+func isKMSAliasARN(s string) bool {
+	parsedARN, err := arn.Parse(s)
+	if err != nil {
+		return false
+	}
 
+	return isKMSAliasName(parsedARN.Resource)
 }

internal/service/comprehend/diff_test.go

@@ -64,5 +64,4 @@ func TestDiffSuppressKMSKeyId(t *testing.T) {
 			}
 		})
 	}
-
 }