fix: fix sqlserverflexalpha

stackit/internal/services/sqlserverflexalpha/database/resource.go

@@ -6,8 +6,8 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
-	"strconv"
 	"strings"
+	"time"
 
 	"github.com/hashicorp/terraform-plugin-framework/path"
 	"github.com/hashicorp/terraform-plugin-framework/resource"
@@ -19,11 +19,12 @@ import (
 
 	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/pkg_gen/sqlserverflexalpha"
 	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/conversion"
+	wait "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/wait/sqlserverflexalpha"
 
 	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/core"
 	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/utils"
 
-	sqlserverflexalphaGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/database/resources_gen"
+	sqlserverflexalphaResGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/database/resources_gen"
 )
 
 var (
@@ -46,9 +47,13 @@ func NewDatabaseResource() resource.Resource {
 }
 
 // resourceModel describes the resource data model.
-type resourceModel = sqlserverflexalphaGen.DatabaseModel
+type resourceModel = sqlserverflexalphaResGen.DatabaseModel
+
+type databaseResource struct {
+	client       *sqlserverflexalpha.APIClient
+	providerData core.ProviderData
+}
 
-// DatabaseResourceIdentityModel describes the resource's identity attributes.
 type DatabaseResourceIdentityModel struct {
 	ProjectID    types.String `tfsdk:"project_id"`
 	Region       types.String `tfsdk:"region"`
@@ -56,12 +61,11 @@ type DatabaseResourceIdentityModel struct {
 	DatabaseName types.String `tfsdk:"database_name"`
 }
 
-type databaseResource struct {
-	client       *sqlserverflexalpha.APIClient
-	providerData core.ProviderData
-}
-
-func (r *databaseResource) Metadata(_ context.Context, req resource.MetadataRequest, resp *resource.MetadataResponse) {
+func (r *databaseResource) Metadata(
+	_ context.Context,
+	req resource.MetadataRequest,
+	resp *resource.MetadataResponse,
+) {
 	resp.TypeName = req.ProviderTypeName + "_sqlserverflexalpha_database"
 }
 
@@ -69,7 +73,7 @@ func (r *databaseResource) Metadata(_ context.Context, req resource.MetadataRequ
 var modifiersFileByte []byte
 
 func (r *databaseResource) Schema(ctx context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
-	s := sqlserverflexalphaGen.DatabaseResourceSchema(ctx)
+	s := sqlserverflexalphaResGen.DatabaseResourceSchema(ctx)
 
 	fields, err := utils.ReadModifiersConfig(modifiersFileByte)
 	if err != nil {
@@ -124,10 +128,10 @@ func (r *databaseResource) Configure(
 		config.WithCustomAuth(r.providerData.RoundTripper),
 		utils.UserAgentConfigOption(r.providerData.Version),
 	}
-	if r.providerData.PostgresFlexCustomEndpoint != "" {
+	if r.providerData.SQLServerFlexCustomEndpoint != "" {
 		apiClientConfigOptions = append(
 			apiClientConfigOptions,
-			config.WithEndpoint(r.providerData.PostgresFlexCustomEndpoint),
+			config.WithEndpoint(r.providerData.SQLServerFlexCustomEndpoint),
 		)
 	} else {
 		apiClientConfigOptions = append(apiClientConfigOptions, config.WithRegion(r.providerData.GetRegion()))
@@ -148,50 +152,74 @@ func (r *databaseResource) Configure(
 }
 
 func (r *databaseResource) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) {
-	var model resourceModel
+	var data resourceModel
+	createErr := "DB create error"
+
+	// Read Terraform plan data into the model
+	resp.Diagnostics.Append(req.Plan.Get(ctx, &data)...)
 
-	diags := req.Plan.Get(ctx, &model)
-	resp.Diagnostics.Append(diags...)
 	if resp.Diagnostics.HasError() {
 		return
 	}
 
 	ctx = core.InitProviderContext(ctx)
 
-	projectId := model.ProjectId.ValueString()
-	region := model.Region.ValueString()
-	instanceId := model.InstanceId.ValueString()
-
+	projectId := data.ProjectId.ValueString()
+	region := data.Region.ValueString()
+	instanceId := data.InstanceId.ValueString()
 	ctx = tflog.SetField(ctx, "project_id", projectId)
-	ctx = tflog.SetField(ctx, "instance_id", instanceId)
 	ctx = tflog.SetField(ctx, "region", region)
+	ctx = tflog.SetField(ctx, "instance_id", instanceId)
 
-	// Generate API request body from model
-	payload, err := toCreatePayload(&model)
+	databaseName := data.Name.ValueString()
+	ctx = tflog.SetField(ctx, "database_name", databaseName)
+
+	payLoad := sqlserverflexalpha.CreateDatabaseRequestPayload{}
+	if !data.Collation.IsNull() && !data.Collation.IsUnknown() {
+		payLoad.Collation = data.Collation.ValueStringPointer()
+	}
+
+	if !data.Compatibility.IsNull() && !data.Compatibility.IsUnknown() {
+		payLoad.Compatibility = data.Compatibility.ValueInt64Pointer()
+	}
+
+	payLoad.Name = data.Name.ValueStringPointer()
+	payLoad.Owner = data.Owner.ValueStringPointer()
+
+	_, err := wait.WaitForUserWaitHandler(
+		ctx,
+		r.client,
+		projectId,
+		instanceId,
+		region,
+		data.Owner.ValueString(),
+	).
+		SetSleepBeforeWait(10 * time.Second).
+		WaitWithContext(ctx)
 	if err != nil {
 		core.LogAndAddError(
 			ctx,
 			&resp.Diagnostics,
-			"Error creating database",
-			fmt.Sprintf("Creating API payload: %v", err),
+			createErr,
+			fmt.Sprintf("Calling API: %v", err),
 		)
 		return
 	}
-	// Create new database
-	databaseResp, err := r.client.CreateDatabaseRequest(
-		ctx,
-		projectId,
-		region,
-		instanceId,
-	).CreateDatabaseRequestPayload(*payload).Execute()
+
+	createResp, err := r.client.CreateDatabaseRequest(ctx, projectId, region, instanceId).
+		CreateDatabaseRequestPayload(payLoad).
+		Execute()
 	if err != nil {
-		core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating database", fmt.Sprintf("Calling API: %v", err))
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			createErr,
+			fmt.Sprintf("Calling API: %v", err),
+		)
 		return
 	}
 
-	ctx = core.LogResponse(ctx)
-
-	if databaseResp == nil || databaseResp.Id == nil {
+	if createResp == nil || createResp.Id == nil {
 		core.LogAndAddError(
 			ctx,
 			&resp.Diagnostics,
@@ -201,11 +229,9 @@ func (r *databaseResource) Create(ctx context.Context, req resource.CreateReques
 		return
 	}
 
-	databaseId := *databaseResp.Id
-	databaseName := model.DatabaseName.String()
+	databaseId := *createResp.Id
 
 	ctx = tflog.SetField(ctx, "database_id", databaseId)
-	ctx = tflog.SetField(ctx, "database_name", databaseName)
 
 	ctx = core.LogResponse(ctx)
 
@@ -221,6 +247,69 @@ func (r *databaseResource) Create(ctx context.Context, req resource.CreateReques
 		return
 	}
 
+	// TODO: is this necessary to wait for the database-> API say 200 ?
+	waitResp, err := wait.CreateDatabaseWaitHandler(
+		ctx,
+		r.client,
+		projectId,
+		instanceId,
+		region,
+		databaseName,
+	).SetSleepBeforeWait(
+		30 * time.Second,
+	).SetTimeout(
+		15 * time.Minute,
+	).WaitWithContext(ctx)
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			createErr,
+			fmt.Sprintf("Database creation waiting: %v", err),
+		)
+		return
+	}
+
+	if waitResp.Id == nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			createErr,
+			"Database creation waiting: returned id is nil",
+		)
+		return
+	}
+
+	if *waitResp.Id != databaseId {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			createErr,
+			"Database creation waiting: returned id is different",
+		)
+		return
+	}
+
+	if *waitResp.Owner != data.Owner.ValueString() {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			createErr,
+			"Database creation waiting: returned owner is different",
+		)
+		return
+	}
+
+	if *waitResp.Name != data.Name.ValueString() {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			createErr,
+			"Database creation waiting: returned name is different",
+		)
+		return
+	}
+
 	database, err := r.client.GetDatabaseRequest(ctx, projectId, region, instanceId, databaseName).Execute()
 	if err != nil {
 		core.LogAndAddError(
@@ -233,7 +322,7 @@ func (r *databaseResource) Create(ctx context.Context, req resource.CreateReques
 	}
 
 	// Map response body to schema
-	err = mapResourceFields(database, &model, region)
+	err = mapResourceFields(database, &data, region)
 	if err != nil {
 		core.LogAndAddError(
 			ctx,
@@ -245,11 +334,13 @@ func (r *databaseResource) Create(ctx context.Context, req resource.CreateReques
 	}
 
 	// Set state to fully populated data
-	resp.Diagnostics.Append(resp.State.Set(ctx, model)...)
+	resp.Diagnostics.Append(resp.State.Set(ctx, data)...)
 	if resp.Diagnostics.HasError() {
 		return
 	}
 
+	// Save data into Terraform state
+
 	tflog.Info(ctx, "sqlserverflexalpha.Database created")
 }
 
@@ -310,7 +401,7 @@ func (r *databaseResource) Read(ctx context.Context, req resource.ReadRequest, r
 		return
 	}
 
-	// Set data returned by API in identity
+	// Save identity into Terraform state
 	identity := DatabaseResourceIdentityModel{
 		ProjectID:    types.StringValue(projectId),
 		Region:       types.StringValue(region),
@@ -372,7 +463,13 @@ func (r *databaseResource) Delete(ctx context.Context, req resource.DeleteReques
 	// Delete existing record set
 	err := r.client.DeleteDatabaseRequestExecute(ctx, projectId, region, instanceId, databaseName)
 	if err != nil {
-		core.LogAndAddError(ctx, &resp.Diagnostics, "Error deleting database", fmt.Sprintf("Calling API: %v", err))
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"Error deleting database",
+			fmt.Sprintf(
+				"Calling API: %v\nname: %s, region: %s, instanceId: %s", err, databaseName, region, instanceId))
+		return
 	}
 
 	ctx = core.LogResponse(ctx)
@@ -388,11 +485,13 @@ func (r *databaseResource) ModifyPlan(
 	req resource.ModifyPlanRequest,
 	resp *resource.ModifyPlanResponse,
 ) { // nolint:gocritic // function signature required by Terraform
-	var configModel resourceModel
+
 	// skip initial empty configuration to avoid follow-up errors
 	if req.Config.Raw.IsNull() {
 		return
 	}
+
+	var configModel resourceModel
 	resp.Diagnostics.Append(req.Config.Get(ctx, &configModel)...)
 	if resp.Diagnostics.HasError() {
 		return
@@ -409,6 +508,23 @@ func (r *databaseResource) ModifyPlan(
 		return
 	}
 
+	var identityModel DatabaseResourceIdentityModel
+	identityModel.ProjectID = planModel.ProjectId
+	identityModel.Region = planModel.Region
+
+	if !planModel.InstanceId.IsNull() && !planModel.InstanceId.IsUnknown() {
+		identityModel.InstanceID = planModel.InstanceId
+	}
+
+	if !planModel.Name.IsNull() && !planModel.Name.IsUnknown() {
+		identityModel.DatabaseName = planModel.Name
+	}
+
+	resp.Diagnostics.Append(resp.Identity.Set(ctx, identityModel)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
 	resp.Diagnostics.Append(resp.Plan.Set(ctx, planModel)...)
 	if resp.Diagnostics.HasError() {
 		return
@@ -416,7 +532,7 @@ func (r *databaseResource) ModifyPlan(
 }
 
 // ImportState imports a resource into the Terraform state on success.
-// The expected import identifier format is: [project_id],[region],[instance_id],[database_id]
+// The expected format of the resource import identifier is: project_id,zone_id,record_set_id
 func (r *databaseResource) ImportState(
 	ctx context.Context,
 	req resource.ImportStateRequest,
@@ -432,36 +548,31 @@ func (r *databaseResource) ImportState(
 				ctx, &resp.Diagnostics,
 				"Error importing database",
 				fmt.Sprintf(
-					"Expected import identifier with format [project_id],[region],[instance_id],[database_name], got %q",
+					"Expected import identifier with format: [project_id],[region],[instance_id],[database_name]  Got: %q",
 					req.ID,
 				),
 			)
 			return
 		}
 
-		databaseId, err := strconv.ParseInt(idParts[3], 10, 64)
-		if err != nil {
-			core.LogAndAddError(
-				ctx,
-				&resp.Diagnostics,
-				"Error importing database",
-				fmt.Sprintf("Invalid database_id format: %q. It must be a valid integer.", idParts[3]),
-			)
-			return
-		}
-
 		resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("project_id"), idParts[0])...)
 		resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("region"), idParts[1])...)
 		resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("instance_id"), idParts[2])...)
-		resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("database_name"), databaseId)...)
+		resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("database_name"), idParts[3])...)
 
-		core.LogAndAddWarning(
-			ctx,
-			&resp.Diagnostics,
-			"Sqlserverflexalpha database imported with empty password",
-			"The database password is not imported as it is only available upon creation of a new database. The password field will be empty.",
-		)
-		tflog.Info(ctx, "Sqlserverflexalpha database state imported")
+		var identityData DatabaseResourceIdentityModel
+		identityData.ProjectID = types.StringValue(idParts[0])
+		identityData.Region = types.StringValue(idParts[1])
+		identityData.InstanceID = types.StringValue(idParts[2])
+		identityData.DatabaseName = types.StringValue(idParts[3])
+
+		resp.Diagnostics.Append(resp.Identity.Set(ctx, &identityData)...)
+		if resp.Diagnostics.HasError() {
+			return
+		}
+
+		tflog.Info(ctx, "sqlserverflexalpha database state imported")
+		return
 	}
 
 	// If no ID is provided, attempt to read identity attributes from the import configuration
@@ -481,7 +592,7 @@ func (r *databaseResource) ImportState(
 	resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("instance_id"), instanceId)...)
 	resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("database_name"), databaseName)...)
 
-	tflog.Info(ctx, "Sqlserverflexalpha database state imported")
+	tflog.Info(ctx, "sqlserverflexalpha database state imported")
 }
 
 // extractIdentityData extracts essential identifiers from the resource model, falling back to the identity model.