chore: Migrates mongodbatlas_cloud_backup_snapshot_export_job to new auto-generated SDK (#2436)

* migrate to new auto-generated SDK

* refactor and deprecate err_msg field

* add changelog entry

* docs

* change deprecation version to 1.20

* reduce changelog explanation

Author: oarbusi

.changelog/2436.txt

@@ -0,0 +1,11 @@
+```release-note:note
+resource/mongodbatlas_cloud_backup_snapshot_export_job: Deprecates the `err_msg` attribute.
+```
+
+```release-note:note
+data-source/mongodbatlas_cloud_backup_snapshot_export_job: Deprecates the `err_msg` attribute.
+```
+
+```release-note:note
+data-source/mongodbatlas_cloud_backup_snapshot_export_jobs: Deprecates the `err_msg` attribute.
+```

docs/data-sources/cloud_backup_snapshot_export_job.md

@@ -49,7 +49,7 @@ In addition to all arguments above, the following attributes are exported:
 * `custom_data` - Custom data to include in the metadata file named `.complete` that Atlas uploads to the bucket when the export job finishes. Custom data can be specified as key and value pairs.
 * `components` - _Returned for sharded clusters only._ Export job details for each replica set in the sharded cluster.
 * `created_at` - Timestamp in ISO 8601 date and time format in UTC when the export job was created.
-* `err_msg` - Error message, only if the export job failed.
+* `err_msg` - Error message, only if the export job failed. **Note:** This attribute is deprecated as it is not being used.
 * `export_status` - _Returned for replica set only._ Status of the export job.
 * `finished_at` - Timestamp in ISO 8601 date and time format in UTC when the export job completes.
 * `export_job_id` - Unique identifier of the export job.

docs/data-sources/cloud_backup_snapshot_export_jobs.md

@@ -58,7 +58,7 @@ In addition to all arguments above, the following attributes are exported:
 * `custom_data` - Custom data to include in the metadata file named `.complete` that Atlas uploads to the bucket when the export job finishes. Custom data can be specified as key and value pairs.
 * `components` - _Returned for sharded clusters only._ Export job details for each replica set in the sharded cluster.
 * `created_at` - Timestamp in ISO 8601 date and time format in UTC when the export job was created.
-* `err_msg` - Error message, only if the export job failed.
+* `err_msg` - Error message, only if the export job failed. **Note:** This attribute is deprecated as it is not being used.
 * `export_status` - _Returned for replica set only._ Status of the export job.
 * `finished_at` - Timestamp in ISO 8601 date and time format in UTC when the export job completes.
 * `export_job_id` - Unique identifier of the export job.

docs/resources/cloud_backup_snapshot_export_job.md

@@ -101,7 +101,7 @@ In addition to all arguments above, the following attributes are exported:
 
 * `components` - _Returned for sharded clusters only._ Export job details for each replica set in the sharded cluster.
 * `created_at` - Timestamp in ISO 8601 date and time format in UTC when the export job was created.
-* `err_msg` - Error message, only if the export job failed.
+* `err_msg` - Error message, only if the export job failed. **Note:** This attribute is deprecated as it is not being used.
 * `export_status` - _Returned for replica set only._ Status of the export job.
 * `finished_at` - Timestamp in ISO 8601 date and time format in UTC when the export job completes.
 * `export_job_id` - Unique identifier of the export job.

internal/service/cloudbackupsnapshotexportjob/data_source_cloud_backup_snapshot_export_job.go

@@ -71,8 +71,9 @@ func DataSource() *schema.Resource {
 				Computed: true,
 			},
 			"err_msg": {
-				Type:     schema.TypeString,
-				Computed: true,
+				Type:       schema.TypeString,
+				Computed:   true,
+				Deprecated: fmt.Sprintf(constant.DeprecationParamByVersion, "1.20.0"),
 			},
 			"export_bucket_id": {
 				Type:     schema.TypeString,

internal/service/cloudbackupsnapshotexportjob/data_source_cloud_backup_snapshot_export_jobs.go

@@ -2,17 +2,20 @@ package cloudbackupsnapshotexportjob
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/id"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/mongodb/terraform-provider-mongodbatlas/internal/common/constant"
+	"github.com/mongodb/terraform-provider-mongodbatlas/internal/common/conversion"
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/config"
-	matlas "go.mongodb.org/atlas/mongodbatlas"
+	"go.mongodb.org/atlas-sdk/v20240530002/admin"
 )
 
 func PluralDataSource() *schema.Resource {
 	return &schema.Resource{
-		ReadContext: dataSourceMongoDBAtlasCloudBackupSnapshotsExportJobsRead,
+		ReadContext: dataSourceRead,
 		Schema: map[string]*schema.Schema{
 			"project_id": {
 				Type:     schema.TypeString,
@@ -79,8 +82,9 @@ func PluralDataSource() *schema.Resource {
 							Computed: true,
 						},
 						"err_msg": {
-							Type:     schema.TypeString,
-							Computed: true,
+							Type:       schema.TypeString,
+							Computed:   true,
+							Deprecated: fmt.Sprintf(constant.DeprecationParamByVersion, "1.20.0"),
 						},
 						"export_bucket_id": {
 							Type:     schema.TypeString,
@@ -117,28 +121,24 @@ func PluralDataSource() *schema.Resource {
 	}
 }
 
-func dataSourceMongoDBAtlasCloudBackupSnapshotsExportJobsRead(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
-	// Get client connection.
-	conn := meta.(*config.MongoDBClient).Atlas
+func dataSourceRead(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
+	connV2 := meta.(*config.MongoDBClient).AtlasV2
 
 	projectID := d.Get("project_id").(string)
 	clusterName := d.Get("cluster_name").(string)
+	pageNum := d.Get("page_num").(int)
+	itemsPerPage := d.Get("items_per_page").(int)
 
-	options := &matlas.ListOptions{
-		PageNum:      d.Get("page_num").(int),
-		ItemsPerPage: d.Get("items_per_page").(int),
-	}
-
-	jobs, _, err := conn.CloudProviderSnapshotExportJobs.List(ctx, projectID, clusterName, options)
+	jobs, _, err := connV2.CloudBackupsApi.ListBackupExportJobs(ctx, projectID, clusterName).PageNum(pageNum).ItemsPerPage(itemsPerPage).Execute()
 	if err != nil {
 		return diag.Errorf("error getting CloudProviderSnapshotExportJobs information: %s", err)
 	}
 
-	if err := d.Set("results", flattenCloudBackupSnapshotExportJobs(jobs.Results)); err != nil {
+	if err := d.Set("results", flattenCloudBackupSnapshotExportJobs(jobs.GetResults())); err != nil {
 		return diag.Errorf("error setting `results`: %s", err)
 	}
 
-	if err := d.Set("total_count", jobs.TotalCount); err != nil {
+	if err := d.Set("total_count", jobs.GetTotalCount()); err != nil {
 		return diag.Errorf("error setting `total_count`: %s", err)
 	}
 
@@ -147,7 +147,7 @@ func dataSourceMongoDBAtlasCloudBackupSnapshotsExportJobsRead(ctx context.Contex
 	return nil
 }
 
-func flattenCloudBackupSnapshotExportJobs(jobs []*matlas.CloudProviderSnapshotExportJob) []map[string]any {
+func flattenCloudBackupSnapshotExportJobs(jobs []admin.DiskBackupExportJob) []map[string]any {
 	var results []map[string]any
 
 	if len(jobs) == 0 {
@@ -158,18 +158,18 @@ func flattenCloudBackupSnapshotExportJobs(jobs []*matlas.CloudProviderSnapshotEx
 
 	for k, job := range jobs {
 		results[k] = map[string]any{
-			"export_job_id":                      job.ID,
-			"created_at":                         job.CreatedAt,
-			"components":                         flattenExportJobsComponents(job.Components),
-			"custom_data":                        flattenExportJobsCustomData(job.CustomData),
-			"err_msg":                            job.ErrMsg,
-			"export_bucket_id":                   job.ExportBucketID,
-			"export_status_exported_collections": job.ExportStatus.ExportedCollections,
-			"export_status_total_collections":    job.ExportStatus.TotalCollections,
-			"finished_at":                        job.FinishedAt,
-			"prefix":                             job.Prefix,
-			"snapshot_id":                        job.SnapshotID,
-			"state":                              job.State,
+			"export_job_id":                      job.GetId(),
+			"created_at":                         conversion.TimePtrToStringPtr(job.CreatedAt),
+			"components":                         flattenExportJobsComponents(job.GetComponents()),
+			"custom_data":                        flattenExportJobsCustomData(job.GetCustomData()),
+			"export_bucket_id":                   job.GetExportBucketId(),
+			"err_msg":                            "",
+			"export_status_exported_collections": job.ExportStatus.GetExportedCollections(),
+			"export_status_total_collections":    job.ExportStatus.GetTotalCollections(),
+			"finished_at":                        conversion.TimePtrToStringPtr(job.FinishedAt),
+			"prefix":                             job.GetPrefix(),
+			"snapshot_id":                        job.GetSnapshotId(),
+			"state":                              job.GetState(),
 		}
 	}
 

internal/service/cloudbackupsnapshotexportjob/resource_cloud_backup_snapshot_export_job.go

@@ -8,18 +8,19 @@ import (
 
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/mongodb/terraform-provider-mongodbatlas/internal/common/constant"
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/common/conversion"
 	"github.com/mongodb/terraform-provider-mongodbatlas/internal/config"
-	matlas "go.mongodb.org/atlas/mongodbatlas"
+	"go.mongodb.org/atlas-sdk/v20240530002/admin"
 )
 
 func Resource() *schema.Resource {
 	return &schema.Resource{
-		CreateContext: resourceMongoDBAtlasCloudBackupSnapshotExportJobCreate,
-		ReadContext:   resourceMongoDBAtlasCloudBackupSnapshotExportJobRead,
+		CreateContext: resourceCreate,
+		ReadContext:   resourceRead,
 		DeleteContext: resourceDelete,
 		Importer: &schema.ResourceImporter{
-			StateContext: resourceMongoDBAtlasCloudBackupSnapshotExportJobImportState,
+			StateContext: resourceImportState,
 		},
 		Schema: returnCloudBackupSnapshotExportJobSchema(),
 	}
@@ -94,8 +95,9 @@ func returnCloudBackupSnapshotExportJobSchema() map[string]*schema.Schema {
 			Computed: true,
 		},
 		"err_msg": {
-			Type:     schema.TypeString,
-			Computed: true,
+			Type:       schema.TypeString,
+			Computed:   true,
+			Deprecated: fmt.Sprintf(constant.DeprecationParamByVersion, "1.20.0"),
 		},
 		"export_status_exported_collections": {
 			Type:     schema.TypeInt,
@@ -120,7 +122,7 @@ func returnCloudBackupSnapshotExportJobSchema() map[string]*schema.Schema {
 	}
 }
 
-func resourceMongoDBAtlasCloudBackupSnapshotExportJobRead(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
+func resourceRead(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
 	exportJob, err := readExportJob(ctx, meta, d)
 	if err != nil {
 		reset := strings.Contains(err.Error(), "404") && !d.IsNewResource()
@@ -135,21 +137,21 @@ func resourceMongoDBAtlasCloudBackupSnapshotExportJobRead(ctx context.Context, d
 	return setExportJobFields(d, exportJob)
 }
 
-func readExportJob(ctx context.Context, meta any, d *schema.ResourceData) (*matlas.CloudProviderSnapshotExportJob, error) {
-	conn := meta.(*config.MongoDBClient).Atlas
+func readExportJob(ctx context.Context, meta any, d *schema.ResourceData) (*admin.DiskBackupExportJob, error) {
+	connV2 := meta.(*config.MongoDBClient).AtlasV2
 	projectID, clusterName, exportID := getRequiredFields(d)
 	if d.Id() != "" && (projectID == "" || clusterName == "" || exportID == "") {
 		ids := conversion.DecodeStateID(d.Id())
 		projectID = ids["project_id"]
 		clusterName = ids["cluster_name"]
 		exportID = ids["export_job_id"]
 	}
-	exportJob, _, err := conn.CloudProviderSnapshotExportJobs.Get(ctx, projectID, clusterName, exportID)
+	exportJob, _, err := connV2.CloudBackupsApi.GetBackupExportJob(ctx, projectID, clusterName, exportID).Execute()
 	if err == nil {
 		d.SetId(conversion.EncodeStateID(map[string]string{
 			"project_id":    projectID,
 			"cluster_name":  clusterName,
-			"export_job_id": exportJob.ID,
+			"export_job_id": exportJob.GetId(),
 		}))
 	}
 	return exportJob, err
@@ -162,61 +164,61 @@ func getRequiredFields(d *schema.ResourceData) (projectID, clusterName, exportID
 	return projectID, clusterName, exportID
 }
 
-func setExportJobFields(d *schema.ResourceData, exportJob *matlas.CloudProviderSnapshotExportJob) diag.Diagnostics {
-	if err := d.Set("export_job_id", exportJob.ID); err != nil {
+func setExportJobFields(d *schema.ResourceData, exportJob *admin.DiskBackupExportJob) diag.Diagnostics {
+	if err := d.Set("export_job_id", exportJob.GetId()); err != nil {
 		return diag.Errorf("error setting `export_job_id` for snapshot export job (%s): %s", d.Id(), err)
 	}
 
-	if err := d.Set("snapshot_id", exportJob.SnapshotID); err != nil {
+	if err := d.Set("snapshot_id", exportJob.GetSnapshotId()); err != nil {
 		return diag.Errorf("error setting `snapshot_id` for snapshot export job (%s): %s", d.Id(), err)
 	}
 
-	if err := d.Set("custom_data", flattenExportJobsCustomData(exportJob.CustomData)); err != nil {
+	if err := d.Set("custom_data", flattenExportJobsCustomData(exportJob.GetCustomData())); err != nil {
 		return diag.Errorf("error setting `custom_data` for snapshot export job (%s): %s", d.Id(), err)
 	}
 
-	if err := d.Set("components", flattenExportJobsComponents(exportJob.Components)); err != nil {
+	if err := d.Set("components", flattenExportJobsComponents(exportJob.GetComponents())); err != nil {
 		return diag.Errorf("error setting `components` for snapshot export job (%s): %s", d.Id(), err)
 	}
 
-	if err := d.Set("created_at", exportJob.CreatedAt); err != nil {
+	if err := d.Set("created_at", conversion.TimePtrToStringPtr(exportJob.CreatedAt)); err != nil {
 		return diag.Errorf("error setting `created_at` for snapshot export job (%s): %s", d.Id(), err)
 	}
 
-	if err := d.Set("err_msg", exportJob.ErrMsg); err != nil {
+	if err := d.Set("err_msg", ""); err != nil {
 		return diag.Errorf("error setting `created_at` for snapshot export job (%s): %s", d.Id(), err)
 	}
 
-	if err := d.Set("export_bucket_id", exportJob.ExportBucketID); err != nil {
+	if err := d.Set("export_bucket_id", exportJob.GetExportBucketId()); err != nil {
 		return diag.Errorf("error setting `created_at` for snapshot export job (%s): %s", d.Id(), err)
 	}
 
 	if exportJob.ExportStatus != nil {
-		if err := d.Set("export_status_exported_collections", exportJob.ExportStatus.ExportedCollections); err != nil {
+		if err := d.Set("export_status_exported_collections", exportJob.ExportStatus.GetExportedCollections()); err != nil {
 			return diag.Errorf("error setting `export_status_exported_collections` for snapshot export job (%s): %s", d.Id(), err)
 		}
 
-		if err := d.Set("export_status_total_collections", exportJob.ExportStatus.TotalCollections); err != nil {
+		if err := d.Set("export_status_total_collections", exportJob.ExportStatus.GetTotalCollections()); err != nil {
 			return diag.Errorf("error setting `export_status_total_collections` for snapshot export job (%s): %s", d.Id(), err)
 		}
 	}
 
-	if err := d.Set("finished_at", exportJob.FinishedAt); err != nil {
+	if err := d.Set("finished_at", conversion.TimePtrToStringPtr(exportJob.FinishedAt)); err != nil {
 		return diag.Errorf("error setting `finished_at` for snapshot export job (%s): %s", d.Id(), err)
 	}
 
-	if err := d.Set("prefix", exportJob.Prefix); err != nil {
+	if err := d.Set("prefix", exportJob.GetPrefix()); err != nil {
 		return diag.Errorf("error setting `prefix` for snapshot export job (%s): %s", d.Id(), err)
 	}
 
-	if err := d.Set("state", exportJob.State); err != nil {
+	if err := d.Set("state", exportJob.GetState()); err != nil {
 		return diag.Errorf("error setting `prefix` for snapshot export job (%s): %s", d.Id(), err)
 	}
 
 	return nil
 }
 
-func flattenExportJobsComponents(components []*matlas.CloudProviderSnapshotExportJobComponent) []map[string]any {
+func flattenExportJobsComponents(components []admin.DiskBackupExportMember) []map[string]any {
 	if len(components) == 0 {
 		return nil
 	}
@@ -225,15 +227,15 @@ func flattenExportJobsComponents(components []*matlas.CloudProviderSnapshotExpor
 
 	for i := range components {
 		customData = append(customData, map[string]any{
-			"export_id":        components[i].ExportID,
-			"replica_set_name": components[i].ReplicaSetName,
+			"export_id":        (components)[i].GetExportId(),
+			"replica_set_name": (components)[i].GetReplicaSetName(),
 		})
 	}
 
 	return customData
 }
 
-func flattenExportJobsCustomData(data []*matlas.CloudProviderSnapshotExportJobCustomData) []map[string]any {
+func flattenExportJobsCustomData(data []admin.BackupLabel) []map[string]any {
 	if len(data) == 0 {
 		return nil
 	}
@@ -242,52 +244,52 @@ func flattenExportJobsCustomData(data []*matlas.CloudProviderSnapshotExportJobCu
 
 	for i := range data {
 		customData = append(customData, map[string]any{
-			"key":   data[i].Key,
-			"value": data[i].Value,
+			"key":   data[i].GetKey(),
+			"value": data[i].GetValue(),
 		})
 	}
 
 	return customData
 }
 
-func resourceMongoDBAtlasCloudBackupSnapshotExportJobCreate(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
-	conn := meta.(*config.MongoDBClient).Atlas
+func resourceCreate(ctx context.Context, d *schema.ResourceData, meta any) diag.Diagnostics {
+	connV2 := meta.(*config.MongoDBClient).AtlasV2
 	projectID := d.Get("project_id").(string)
 	clusterName := d.Get("cluster_name").(string)
 
-	request := &matlas.CloudProviderSnapshotExportJob{
-		SnapshotID:     d.Get("snapshot_id").(string),
-		ExportBucketID: d.Get("export_bucket_id").(string),
+	request := &admin.DiskBackupExportJobRequest{
+		SnapshotId:     d.Get("snapshot_id").(string),
+		ExportBucketId: d.Get("export_bucket_id").(string),
 		CustomData:     expandExportJobCustomData(d),
 	}
 
-	jobResponse, _, err := conn.CloudProviderSnapshotExportJobs.Create(ctx, projectID, clusterName, request)
+	jobResponse, _, err := connV2.CloudBackupsApi.CreateBackupExportJob(ctx, projectID, clusterName, request).Execute()
 	if err != nil {
 		return diag.Errorf("error creating snapshot export job: %s", err)
 	}
 
-	if err := d.Set("export_job_id", jobResponse.ID); err != nil {
-		return diag.Errorf("error setting `export_job_id` for snapshot export job (%s): %s", jobResponse.ID, err)
+	if err := d.Set("export_job_id", jobResponse.Id); err != nil {
+		return diag.Errorf("error setting `export_job_id` for snapshot export job (%s): %s", *jobResponse.Id, err)
 	}
-	return resourceMongoDBAtlasCloudBackupSnapshotExportJobRead(ctx, d, meta)
+	return resourceRead(ctx, d, meta)
 }
 
-func expandExportJobCustomData(d *schema.ResourceData) []*matlas.CloudProviderSnapshotExportJobCustomData {
+func expandExportJobCustomData(d *schema.ResourceData) *[]admin.BackupLabel {
 	customData := d.Get("custom_data").(*schema.Set)
-	res := make([]*matlas.CloudProviderSnapshotExportJobCustomData, customData.Len())
+	res := make([]admin.BackupLabel, customData.Len())
 
 	for i, val := range customData.List() {
 		v := val.(map[string]any)
-		res[i] = &matlas.CloudProviderSnapshotExportJobCustomData{
-			Key:   v["key"].(string),
-			Value: v["value"].(string),
+		res[i] = admin.BackupLabel{
+			Key:   conversion.Pointer(v["key"].(string)),
+			Value: conversion.Pointer(v["value"].(string)),
 		}
 	}
 
-	return res
+	return &res
 }
 
-func resourceMongoDBAtlasCloudBackupSnapshotExportJobImportState(ctx context.Context, d *schema.ResourceData, meta any) ([]*schema.ResourceData, error) {
+func resourceImportState(ctx context.Context, d *schema.ResourceData, meta any) ([]*schema.ResourceData, error) {
 	conn := meta.(*config.MongoDBClient).Atlas
 
 	parts := strings.SplitN(d.Id(), "--", 3)