fix: fix sqlserverflexalpha (#61)

## Description

<!-- **Please link some issue here describing what you are trying to achieve.**

In case there is no issue present for your PR, please consider creating one.
At least please give us some description what you are trying to achieve and why your change is needed. -->

relates to #1234

## Checklist

- [ ] Issue was linked above
- [ ] Code format was applied: `make fmt`
- [ ] Examples were added / adjusted (see `examples/` directory)
- [x] Docs are up-to-date: `make generate-docs` (will be checked by CI)
- [ ] Unit tests got implemented or updated
- [ ] Acceptance tests got implemented or updated (see e.g. [here](f5f99d1709/stackit/internal/services/dns/dns_acc_test.go))
- [x] Unit tests are passing: `make test` (will be checked by CI)
- [x] No linter issues: `make lint` (will be checked by CI)

Reviewed-on: #61
Co-authored-by: Marcel S. Henselin <marcel.henselin@stackit.cloud>
Co-committed-by: Marcel S. Henselin <marcel.henselin@stackit.cloud>

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

@@ -10,34 +10,34 @@ import (
 	"github.com/hashicorp/terraform-plugin-framework/diag"
 	"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/pkg_gen/sqlserverflexalpha"
 	"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"
-	sqlserverflexalphaGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/database/datasources_gen"
-	sqlserverflexUtils "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/utils"
 	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/utils"
-)
 
-// dataSourceModel maps the data source schema data.
-type dataSourceModel struct {
-	sqlserverflexalphaGen.DatabaseModel
-	TerraformID types.String `tfsdk:"id"`
-}
+	sqlserverflexalphaPkg "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/pkg_gen/sqlserverflexalpha"
+	sqlserverflexalphaGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/database/datasources_gen"
+)
 
 var _ datasource.DataSource = (*databaseDataSource)(nil)
 
-// NewDatabaseDataSource creates a new database data source.
+const errorPrefix = "[sqlserverflexalpha - Database]"
+
 func NewDatabaseDataSource() datasource.DataSource {
 	return &databaseDataSource{}
 }
 
+type dataSourceModel struct {
+	sqlserverflexalphaGen.DatabaseModel
+	TerraformId types.String `tfsdk:"id"`
+}
+
 type databaseDataSource struct {
-	client       *sqlserverflexalpha.APIClient
+	client       *sqlserverflexalphaPkg.APIClient
 	providerData core.ProviderData
 }
 
-// Metadata returns the data source type name.
 func (d *databaseDataSource) Metadata(
 	_ context.Context,
 	req datasource.MetadataRequest,
@@ -46,16 +46,13 @@ func (d *databaseDataSource) Metadata(
 	resp.TypeName = req.ProviderTypeName + "_sqlserverflexalpha_database"
 }
 
-// Schema defines the data source schema.
 func (d *databaseDataSource) Schema(ctx context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
-	s := sqlserverflexalphaGen.DatabaseDataSourceSchema(ctx)
-	s.Attributes["id"] = schema.StringAttribute{
-		Description: "Terraform's internal resource ID. It is structured as \\\"`project_id`,`region`,`instance_id`," +
-			"`database_id`\\\".\",",
-		Computed: true,
+	resp.Schema = sqlserverflexalphaGen.DatabaseDataSourceSchema(ctx)
+	resp.Schema.Attributes["id"] = schema.StringAttribute{
+		Computed:            true,
+		Description:         "The terraform internal identifier.",
+		MarkdownDescription: "The terraform internal identifier.",
 	}
-
-	resp.Schema = s
 }
 
 // Configure adds the provider configured client to the data source.
@@ -70,19 +67,41 @@ func (d *databaseDataSource) Configure(
 		return
 	}
 
-	apiClient := sqlserverflexUtils.ConfigureClient(ctx, &d.providerData, &resp.Diagnostics)
-	if resp.Diagnostics.HasError() {
+	apiClientConfigOptions := []config.ConfigurationOption{
+		config.WithCustomAuth(d.providerData.RoundTripper),
+		utils.UserAgentConfigOption(d.providerData.Version),
+	}
+	if d.providerData.SQLServerFlexCustomEndpoint != "" {
+		apiClientConfigOptions = append(
+			apiClientConfigOptions,
+			config.WithEndpoint(d.providerData.SQLServerFlexCustomEndpoint),
+		)
+	} else {
+		apiClientConfigOptions = append(
+			apiClientConfigOptions,
+			config.WithRegion(d.providerData.GetRegion()),
+		)
+	}
+	apiClient, err := sqlserverflexalphaPkg.NewAPIClient(apiClientConfigOptions...)
+	if err != nil {
+		resp.Diagnostics.AddError(
+			"Error configuring API client",
+			fmt.Sprintf(
+				"Configuring client: %v. This is an error related to the provider configuration, not to the resource configuration",
+				err,
+			),
+		)
 		return
 	}
 	d.client = apiClient
-	tflog.Info(ctx, "SQL SERVER Flex alpha database client configured")
+	tflog.Info(ctx, fmt.Sprintf("%s client configured", errorPrefix))
 }
 
-// Read retrieves the resource's state from the API.
 func (d *databaseDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) {
-	var model dataSourceModel
-	diags := req.Config.Get(ctx, &model)
-	resp.Diagnostics.Append(diags...)
+	var data dataSourceModel
+	// Read Terraform configuration data into the model
+	resp.Diagnostics.Append(req.Config.Get(ctx, &data)...)
+
 	if resp.Diagnostics.HasError() {
 		return
 	}
@@ -90,22 +109,17 @@ func (d *databaseDataSource) Read(ctx context.Context, req datasource.ReadReques
 	ctx = core.InitProviderContext(ctx)
 
 	// Extract identifiers from the plan
-	projectId := model.ProjectId.ValueString()
-	instanceId := model.InstanceId.ValueString()
-	region := d.providerData.GetRegionWithOverride(model.Region)
-	databaseName := model.DatabaseName.ValueString()
+	projectId := data.ProjectId.ValueString()
+	region := d.providerData.GetRegionWithOverride(data.Region)
+	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, "database_name", databaseName)
+	ctx = tflog.SetField(ctx, "instance_id", instanceId)
+
+	databaseName := data.DatabaseName.ValueString()
 
-	// Fetch database from the API
 	databaseResp, err := d.client.GetDatabaseRequest(ctx, projectId, region, instanceId, databaseName).Execute()
-
-	if resp.Diagnostics.HasError() {
-		return
-	}
 	if err != nil {
 		handleReadError(ctx, &resp.Diagnostics, err, projectId, instanceId)
 		resp.State.RemoveResource(ctx)
@@ -113,9 +127,8 @@ func (d *databaseDataSource) Read(ctx context.Context, req datasource.ReadReques
 	}
 
 	ctx = core.LogResponse(ctx)
-
 	// Map response body to schema and populate Computed attribute values
-	err = mapFields(databaseResp, &model, region)
+	err = mapFields(databaseResp, &data, region)
 	if err != nil {
 		core.LogAndAddError(
 			ctx,
@@ -126,14 +139,11 @@ func (d *databaseDataSource) Read(ctx context.Context, req datasource.ReadReques
 		return
 	}
 
-	// Set refreshed state
-	diags = resp.State.Set(ctx, model)
-	resp.Diagnostics.Append(diags...)
-	if resp.Diagnostics.HasError() {
-		return
-	}
+	// Save data into Terraform state
+	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
+
+	tflog.Info(ctx, "SQL Server Flex beta database read")
 
-	tflog.Info(ctx, "SQL Server Flex alpha database read")
 }
 
 // handleReadError centralizes API error handling for the Read operation.

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

@@ -41,7 +41,7 @@ func mapFields(source *sqlserverflexalpha.GetDatabaseResponse, model *dataSource
 	model.CompatibilityLevel = types.Int64Value(source.GetCompatibilityLevel())
 	model.CollationName = types.StringValue(source.GetCollationName())
 
-	model.TerraformID = utils.BuildInternalTerraformId(
+	model.TerraformId = utils.BuildInternalTerraformId(
 		model.ProjectId.ValueString(),
 		region,
 		model.InstanceId.ValueString(),
@@ -80,6 +80,12 @@ func mapResourceFields(source *sqlserverflexalpha.GetDatabaseResponse, model *re
 	model.ProjectId = types.StringValue(model.ProjectId.ValueString())
 	model.InstanceId = types.StringValue(model.InstanceId.ValueString())
 
+	model.Compatibility = types.Int64Value(source.GetCompatibilityLevel())
+	model.CompatibilityLevel = types.Int64Value(source.GetCompatibilityLevel())
+
+	model.Collation = types.StringValue(source.GetCollationName()) // it does not come back from api
+	model.CollationName = types.StringValue(source.GetCollationName())
+
 	return nil
 }
 

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

@@ -35,7 +35,7 @@ func TestMapFields(t *testing.T) {
 					Name:               utils.Ptr("my-db"),
 					CollationName:      utils.Ptr("collation"),
 					CompatibilityLevel: utils.Ptr(int64(150)),
-					Owner:              utils.Ptr("\"my-owner\""),
+					Owner:              utils.Ptr("my-owner"),
 				},
 				model: &dataSourceModel{
 					DatabaseModel: datasource.DatabaseModel{
@@ -58,7 +58,7 @@ func TestMapFields(t *testing.T) {
 						CompatibilityLevel: types.Int64Value(150),
 						CollationName:      types.StringValue("collation"),
 					},
-					TerraformID: types.StringValue("my-project,eu01,my-instance,my-db"),
+					TerraformId: types.StringValue("my-project,eu01,my-instance,my-db"),
 				},
 			},
 		},
@@ -127,7 +127,7 @@ func TestMapResourceFields(t *testing.T) {
 				source: &sqlserverflexalpha.GetDatabaseResponse{
 					Id:    utils.Ptr(int64(1)),
 					Name:  utils.Ptr("my-db"),
-					Owner: utils.Ptr("\"my-owner\""),
+					Owner: utils.Ptr("my-owner"),
 				},
 				model: &resourceModel{
 					ProjectId:  types.StringValue("my-project"),
@@ -137,13 +137,17 @@ func TestMapResourceFields(t *testing.T) {
 			},
 			expected: expected{
 				model: &resourceModel{
-					Id:           types.Int64Value(1),
-					Name:         types.StringValue("my-db"),
-					DatabaseName: types.StringValue("my-db"),
-					InstanceId:   types.StringValue("my-instance"),
-					ProjectId:    types.StringValue("my-project"),
-					Region:       types.StringValue("eu01"),
-					Owner:        types.StringValue("my-owner"),
+					Id:                 types.Int64Value(1),
+					Name:               types.StringValue("my-db"),
+					Compatibility:      types.Int64Value(0),
+					CompatibilityLevel: types.Int64Value(0),
+					Collation:          types.StringValue(""),
+					CollationName:      types.StringValue(""),
+					DatabaseName:       types.StringValue("my-db"),
+					InstanceId:         types.StringValue("my-instance"),
+					ProjectId:          types.StringValue("my-project"),
+					Region:             types.StringValue("eu01"),
+					Owner:              types.StringValue("my-owner"),
 				},
 			},
 		},

stackit/internal/services/sqlserverflexalpha/database/planModifiers.yaml

@@ -31,7 +31,7 @@ fields:
 
   - name: 'owner'
     modifiers:
-      - 'RequiresReplace'
+      - 'UseStateForUnknown'
 
   - name: 'database_name'
     modifiers:
@@ -43,6 +43,7 @@ fields:
 
   - name: 'compatibility'
     modifiers:
+      - 'UseStateForUnknown'
       - 'RequiresReplace'
   
   - name: 'compatibility_level'

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.