feat: update SQL Server Flex client configuration

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

@@ -3,9 +3,10 @@ package sqlserverflexbeta
 import (
 	"context"
 	_ "embed"
+	"errors"
 	"fmt"
+	"net/http"
 	"strings"
-	"time"
 
 	"github.com/hashicorp/terraform-plugin-framework/path"
 	"github.com/hashicorp/terraform-plugin-framework/resource"
@@ -13,10 +14,9 @@ import (
 	"github.com/hashicorp/terraform-plugin-framework/types"
 	"github.com/hashicorp/terraform-plugin-log/tflog"
 	"github.com/stackitcloud/stackit-sdk-go/core/config"
-	"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/sqlserverflexbeta"
-
+	"github.com/stackitcloud/stackit-sdk-go/core/oapierror"
 	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/pkg_gen/sqlserverflexbeta"
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/conversion"
 
 	"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"
@@ -30,6 +30,13 @@ var (
 	_ resource.ResourceWithImportState = &databaseResource{}
 	_ resource.ResourceWithModifyPlan  = &databaseResource{}
 	_ resource.ResourceWithIdentity    = &databaseResource{}
+
+	// Define errors
+	errDatabaseNotFound = errors.New("database not found")
+
+	// Error message constants
+	extractErrorSummary = "extracting failed"
+	extractErrorMessage = "Extracting identity data: %v"
 )
 
 func NewDatabaseResource() resource.Resource {
@@ -192,18 +199,24 @@ func (r *databaseResource) Create(ctx context.Context, req resource.CreateReques
 		return
 	}
 
-	ctx = core.LogResponse(ctx)
-	createId, ok := createResp.GetIdOk()
-	if !ok {
+	if createResp == nil || createResp.Id == nil {
 		core.LogAndAddError(
 			ctx,
 			&resp.Diagnostics,
-			createErr,
-			fmt.Sprintf("Calling API: %v", err),
+			"Error creating database",
+			"API didn't return database Id. A database might have been created",
 		)
+		return
 	}
 
-	waitResp, err := wait.CreateDatabaseWaitHandler(
+	databaseId := *createResp.Id
+
+	ctx = tflog.SetField(ctx, "database_id", databaseId)
+
+	ctx = core.LogResponse(ctx)
+
+	// TODO: is this neccessary to wait for the database-> API say 200 ?
+	/*waitResp, err := wait.CreateDatabaseWaitHandler(
 		ctx,
 		r.client,
 		projectId,
@@ -263,23 +276,58 @@ func (r *databaseResource) Create(ctx context.Context, req resource.CreateReques
 			"Database creation waiting: returned name is different",
 		)
 		return
+	}*/
+
+	database, err := r.client.GetDatabaseRequest(ctx, projectId, region, instanceId, databaseName).Execute()
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"Error creating database",
+			fmt.Sprintf("Getting database details after creation: %v", err),
+		)
+		return
 	}
 
-	data.Id = types.Int64PointerValue(waitResp.Id)
-	data.Name = types.StringPointerValue(waitResp.Name)
+	// Map response body to schema
+	err = mapResourceFields(database, &data, region)
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"Error creating database",
+			fmt.Sprintf("Processing API payload: %v", err),
+		)
+		return
+	}
+
+	// Set data returned by API in identity
+	identity := DatabaseResourceIdentityModel{
+		ProjectID:    types.StringValue(projectId),
+		Region:       types.StringValue(region),
+		InstanceID:   types.StringValue(instanceId),
+		DatabaseName: types.StringValue(databaseName),
+	}
+	resp.Diagnostics.Append(resp.Identity.Set(ctx, identity)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	// Set state to fully populated data
+	resp.Diagnostics.Append(resp.State.Set(ctx, data)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
 
 	// Save data into Terraform state
-	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
 
 	tflog.Info(ctx, "sqlserverflexbeta.Database created")
 }
 
 func (r *databaseResource) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse) {
-	var data resourceModel
-	readErr := "[Database Read]"
-
-	// Read Terraform prior state data into the model
-	resp.Diagnostics.Append(req.State.Get(ctx, &data)...)
+	var model resourceModel
+	diags := req.State.Get(ctx, &model)
+	resp.Diagnostics.Append(diags...)
 	if resp.Diagnostics.HasError() {
 		return
 	}
@@ -293,78 +341,66 @@ func (r *databaseResource) Read(ctx context.Context, req resource.ReadRequest, r
 
 	ctx = core.InitProviderContext(ctx)
 
-	projectId := identityData.ProjectID.ValueString()
-	region := identityData.Region.ValueString()
-	ctx = tflog.SetField(ctx, "project_id", projectId)
-	ctx = tflog.SetField(ctx, "region", region)
-
-	instanceId := identityData.InstanceID.ValueString()
-	ctx = tflog.SetField(ctx, "instance_id", instanceId)
-
-	dbName := identityData.DatabaseName.ValueString()
-	ctx = tflog.SetField(ctx, "database_name", dbName)
-
-	getResp, err := r.client.GetDatabaseRequest(ctx, projectId, region, instanceId, dbName).Execute()
-	if err != nil {
+	projectId, instanceId, region, databaseName, errExt := r.extractIdentityData(model, identityData)
+	if errExt != nil {
 		core.LogAndAddError(
 			ctx,
 			&resp.Diagnostics,
-			readErr,
-			fmt.Sprintf("Calling API: %v", err),
+			extractErrorSummary,
+			fmt.Sprintf(extractErrorMessage, errExt),
 		)
+	}
+
+	ctx = tflog.SetField(ctx, "project_id", projectId)
+	ctx = tflog.SetField(ctx, "instance_id", instanceId)
+	ctx = tflog.SetField(ctx, "region", region)
+	ctx = tflog.SetField(ctx, "database_name", databaseName)
+
+	databaseResp, err := r.client.GetDatabaseRequest(ctx, projectId, region, instanceId, databaseName).Execute()
+	if err != nil {
+		oapiErr, ok := err.(*oapierror.GenericOpenAPIError) //nolint:errorlint //complaining that error.As should be used to catch wrapped errors, but this error should not be wrapped
+		if (ok && oapiErr.StatusCode == http.StatusNotFound) || errors.Is(err, errDatabaseNotFound) {
+			resp.State.RemoveResource(ctx)
+			return
+		}
+		core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading database", fmt.Sprintf("Calling API: %v", err))
 		return
 	}
 
 	ctx = core.LogResponse(ctx)
 
-	data.Id = types.Int64Value(getResp.GetId())
-	data.Owner = types.StringValue(getResp.GetOwner())
-	data.Name = types.StringValue(getResp.GetName())
-	data.DatabaseName = types.StringValue(getResp.GetName())
-	data.CollationName = types.StringValue(getResp.GetCollationName())
-	data.CompatibilityLevel = types.Int64Value(getResp.GetCompatibilityLevel())
+	// Map response body to schema
+	err = mapResourceFields(databaseResp, &model, region)
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"Error reading database",
+			fmt.Sprintf("Processing API payload: %v", err),
+		)
+		return
+	}
+
+	// Set refreshed state
+	diags = resp.State.Set(ctx, model)
+	resp.Diagnostics.Append(diags...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
 
-	// Save updated data into Terraform state
-	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
 	tflog.Info(ctx, "sqlserverflexbeta.Database read")
 }
 
 func (r *databaseResource) Update(ctx context.Context, req resource.UpdateRequest, resp *resource.UpdateResponse) {
-	var data resourceModel
-
-	// Read Terraform prior state data into the model
-	resp.Diagnostics.Append(req.State.Get(ctx, &data)...)
-	if resp.Diagnostics.HasError() {
-		return
-	}
-
-	// Read identity data
-	var identityData DatabaseResourceIdentityModel
-	resp.Diagnostics.Append(req.Identity.Get(ctx, &identityData)...)
-	if resp.Diagnostics.HasError() {
-		return
-	}
-
-	ctx = core.InitProviderContext(ctx)
-
-	projectId := identityData.ProjectID.ValueString()
-	region := identityData.Region.ValueString()
-	ctx = tflog.SetField(ctx, "project_id", projectId)
-	ctx = tflog.SetField(ctx, "region", region)
-
-	// Todo: Update API call logic
-
-	// Save updated data into Terraform state
-	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
-
-	tflog.Info(ctx, "sqlserverflexbeta.Database updated")
+	// TODO: Check update api endpoint - not available at the moment, so return an error for now
+	core.LogAndAddError(ctx, &resp.Diagnostics, "Error updating database", "Database can't be updated")
 }
 
 func (r *databaseResource) Delete(ctx context.Context, req resource.DeleteRequest, resp *resource.DeleteResponse) {
-	var data resourceModel
-
-	// Read Terraform prior state data into the model
-	resp.Diagnostics.Append(req.State.Get(ctx, &data)...)
+	// nolint:gocritic // function signature required by Terraform
+	var model resourceModel
+	diags := req.State.Get(ctx, &model)
+	resp.Diagnostics.Append(diags...)
 	if resp.Diagnostics.HasError() {
 		return
 	}
@@ -378,12 +414,28 @@ func (r *databaseResource) Delete(ctx context.Context, req resource.DeleteReques
 
 	ctx = core.InitProviderContext(ctx)
 
-	projectId := identityData.ProjectID.ValueString()
-	region := identityData.Region.ValueString()
-	ctx = tflog.SetField(ctx, "project_id", projectId)
-	ctx = tflog.SetField(ctx, "region", region)
+	projectId, instanceId, region, databaseName, errExt := r.extractIdentityData(model, identityData)
+	if errExt != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			extractErrorSummary,
+			fmt.Sprintf(extractErrorMessage, errExt),
+		)
+	}
 
-	// Todo: Delete API call logic
+	ctx = tflog.SetField(ctx, "project_id", projectId)
+	ctx = tflog.SetField(ctx, "instance_id", instanceId)
+	ctx = tflog.SetField(ctx, "region", region)
+	ctx = tflog.SetField(ctx, "database_name", databaseName)
+
+	// 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))
+	}
+
+	ctx = core.LogResponse(ctx)
 
 	tflog.Info(ctx, "sqlserverflexbeta.Database deleted")
 }
@@ -504,3 +556,46 @@ func (r *databaseResource) ImportState(
 
 	tflog.Info(ctx, "Sqlserverflexbeta database state imported")
 }
+
+// extractIdentityData extracts essential identifiers from the resource model, falling back to the identity model.
+func (r *databaseResource) extractIdentityData(
+	model resourceModel,
+	identity DatabaseResourceIdentityModel,
+) (projectId, region, instanceId, databaseName string, err error) {
+	if !model.DatabaseName.IsNull() && !model.DatabaseName.IsUnknown() {
+		databaseName = model.DatabaseName.ValueString()
+	} else {
+		if identity.DatabaseName.IsNull() || identity.DatabaseName.IsUnknown() {
+			return "", "", "", "", fmt.Errorf("database_name not found in config")
+		}
+		databaseName = identity.DatabaseName.ValueString()
+	}
+
+	if !model.ProjectId.IsNull() && !model.ProjectId.IsUnknown() {
+		projectId = model.ProjectId.ValueString()
+	} else {
+		if identity.ProjectID.IsNull() || identity.ProjectID.IsUnknown() {
+			return "", "", "", "", fmt.Errorf("project_id not found in config")
+		}
+		projectId = identity.ProjectID.ValueString()
+	}
+
+	if !model.Region.IsNull() && !model.Region.IsUnknown() {
+		region = r.providerData.GetRegionWithOverride(model.Region)
+	} else {
+		if identity.Region.IsNull() || identity.Region.IsUnknown() {
+			return "", "", "", "", fmt.Errorf("region not found in config")
+		}
+		region = r.providerData.GetRegionWithOverride(identity.Region)
+	}
+
+	if !model.InstanceId.IsNull() && !model.InstanceId.IsUnknown() {
+		instanceId = model.InstanceId.ValueString()
+	} else {
+		if identity.InstanceID.IsNull() || identity.InstanceID.IsUnknown() {
+			return "", "", "", "", fmt.Errorf("instance_id not found in config")
+		}
+		instanceId = identity.InstanceID.ValueString()
+	}
+	return projectId, region, instanceId, databaseName, nil
+}