feat: update SQL Server Flex client configuration

stackit/internal/services/sqlserverflexbeta/user/datasource.go

@@ -8,13 +8,12 @@ import (
 	"github.com/hashicorp/terraform-plugin-framework/datasource"
 	"github.com/hashicorp/terraform-plugin-framework/types"
 	"github.com/hashicorp/terraform-plugin-log/tflog"
+	"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"
+	sqlserverflexUtils "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/utils"
 	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/utils"
 
 	sqlserverflexbetaPkg "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/pkg_gen/sqlserverflexbeta"
-
-	// sqlserverflexbetaUtils "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/utils"
-
 	sqlserverflexbetaGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/user/datasources_gen"
 )
 
@@ -29,7 +28,7 @@ func NewUserDataSource() datasource.DataSource {
 type dataSourceModel struct {
 	DefaultDatabase types.String `tfsdk:"default_database"`
 	Host            types.String `tfsdk:"host"`
-	Id              types.Int64  `tfsdk:"id"`
+	Id              types.String `tfsdk:"id"`
 	InstanceId      types.String `tfsdk:"instance_id"`
 	Port            types.Int64  `tfsdk:"port"`
 	ProjectId       types.String `tfsdk:"project_id"`
@@ -63,50 +62,52 @@ func (d *userDataSource) Configure(
 	req datasource.ConfigureRequest,
 	resp *datasource.ConfigureResponse,
 ) {
-	//var ok bool
-	//d.providerData, ok = conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
-	//if !ok {
-	//	return
-	//}
-	//
-	//apiClient := sqlserverflexbetaUtils.ConfigureClient(ctx, &d.providerData, &resp.Diagnostics)
-	//if resp.Diagnostics.HasError() {
-	//	return
-	//}
-	//d.client = apiClient
-	tflog.Info(ctx, fmt.Sprintf("%s client configured", errorPrefix))
+	var ok bool
+	d.providerData, ok = conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
+	if !ok {
+		return
+	}
+
+	apiClient := sqlserverflexUtils.ConfigureClient(ctx, &d.providerData, &resp.Diagnostics)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	d.client = apiClient
+	tflog.Info(ctx, "SQL SERVER Flex alpha database client configured")
 }
 
 func (d *userDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) {
-	var data dataSourceModel
-
-	// Read Terraform configuration data into the model
-	resp.Diagnostics.Append(req.Config.Get(ctx, &data)...)
-
+	var model dataSourceModel
+	diags := req.Config.Get(ctx, &model)
+	resp.Diagnostics.Append(diags...)
 	if resp.Diagnostics.HasError() {
 		return
 	}
 
 	ctx = core.InitProviderContext(ctx)
 
-	projectId := data.ProjectId.ValueString()
-	region := d.providerData.GetRegionWithOverride(data.Region)
-	instanceId := data.InstanceId.ValueString()
-	userId := data.UserId.ValueInt64()
-
+	projectId := model.ProjectId.ValueString()
+	instanceId := model.InstanceId.ValueString()
+	userId := model.UserId.ValueInt64()
+	region := d.providerData.GetRegionWithOverride(model.Region)
 	ctx = tflog.SetField(ctx, "project_id", projectId)
-	ctx = tflog.SetField(ctx, "region", region)
 	ctx = tflog.SetField(ctx, "instance_id", instanceId)
 	ctx = tflog.SetField(ctx, "user_id", userId)
+	ctx = tflog.SetField(ctx, "region", region)
 
-	userResp, err := d.client.GetUserRequest(ctx, projectId, region, instanceId, userId).Execute()
+	recordSetResp, err := d.client.GetUserRequest(ctx, projectId, region, instanceId, userId).Execute()
 	if err != nil {
 		utils.LogError(
 			ctx,
 			&resp.Diagnostics,
 			err,
 			"Reading user",
-			fmt.Sprintf("user with ID %q does not exist in project %q.", userId, projectId),
+			fmt.Sprintf(
+				"User with ID %q or instance with ID %q does not exist in project %q.",
+				userId,
+				instanceId,
+				projectId,
+			),
 			map[int]string{
 				http.StatusForbidden: fmt.Sprintf("Project with ID %q not found or forbidden access", projectId),
 			},
@@ -117,22 +118,23 @@ func (d *userDataSource) Read(ctx context.Context, req datasource.ReadRequest, r
 
 	ctx = core.LogResponse(ctx)
 
-	// Todo: Read API call logic
-
-	// Example data value setting
-	// data.Id = types.StringValue("example-id")
-
-	err = mapResponseToModel(ctx, userResp, &data, resp.Diagnostics)
+	// Map response body to schema and populate Computed attribute values
+	err = mapDataSourceFields(recordSetResp, &model, region)
 	if err != nil {
 		core.LogAndAddError(
 			ctx,
 			&resp.Diagnostics,
-			fmt.Sprintf("%s Read", errorPrefix),
+			"Error reading user",
 			fmt.Sprintf("Processing API payload: %v", err),
 		)
 		return
 	}
 
-	// Save data into Terraform state
-	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
+	// Set refreshed state
+	diags = resp.State.Set(ctx, model)
+	resp.Diagnostics.Append(diags...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	tflog.Info(ctx, "SQLServer Flex beta instance read")
 }

stackit/internal/services/sqlserverflexbeta/user/functions.go

@@ -1,98 +0,0 @@
-package sqlserverflexbeta
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/hashicorp/terraform-plugin-framework/diag"
-	"github.com/hashicorp/terraform-plugin-framework/types"
-
-	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/pkg_gen/sqlserverflexbeta"
-)
-
-func mapResponseToModel(
-	ctx context.Context,
-	resp *sqlserverflexbeta.GetUserResponse,
-	m *dataSourceModel,
-	tfDiags diag.Diagnostics,
-) error {
-	if resp == nil {
-		return fmt.Errorf("response is nil")
-	}
-
-	m.Id = types.Int64Value(resp.GetId())
-	m.UserId = types.Int64Value(resp.GetId())
-	m.Username = types.StringValue(resp.GetUsername())
-	m.Port = types.Int64Value(resp.GetPort())
-	m.Host = types.StringValue(resp.GetHost())
-	m.DefaultDatabase = types.StringValue(resp.GetDefaultDatabase())
-	m.Status = types.StringValue(resp.GetStatus())
-
-	if resp.Roles != nil {
-		roles, diags := types.ListValueFrom(ctx, types.StringType, *resp.Roles)
-		tfDiags.Append(diags...)
-		if tfDiags.HasError() {
-			return fmt.Errorf("failed to map roles")
-		}
-		m.Roles = roles
-	} else {
-		m.Roles = types.ListNull(types.StringType)
-	}
-
-	if resp.Status != nil {
-		m.Status = types.StringValue(*resp.Status)
-	} else {
-		m.Status = types.StringNull()
-	}
-
-	// TODO: complete and refactor
-
-	/*
-		sampleList, diags := types.ListValueFrom(ctx, types.StringType, resp.GetList())
-		tfDiags.Append(diags...)
-		if diags.HasError() {
-			return fmt.Errorf(
-				"error converting list response value",
-			)
-		}
-		sample, diags := sqlserverflexbetaResGen.NewSampleValue(
-			sqlserverflexbetaResGen.SampleValue{}.AttributeTypes(ctx),
-			map[string]attr.Value{
-				"field":     types.StringValue(string(resp.GetField())),
-			},
-		)
-		tfDiags.Append(diags...)
-		if diags.HasError() {
-			return fmt.Errorf(
-				"error converting sample response value",
-				"sample",
-				types.StringValue(string(resp.GetField())),
-			)
-		}
-		m.Sample = sample
-	*/
-	return nil
-}
-
-//func toCreatePayload(
-//	ctx context.Context,
-//	model *resourceModel,
-//) (*sqlserverflexbeta.CreateUserRequestPayload, error) {
-//	if model == nil {
-//		return nil, fmt.Errorf("nil model")
-//	}
-//
-//	var roles []sqlserverflexbeta.UserRole
-//	if !model.Roles.IsNull() && !model.Roles.IsUnknown() {
-//		diags := model.Roles.ElementsAs(ctx, &roles, false)
-//		if diags.HasError() {
-//			return nil, fmt.Errorf("failed to convert roles: %v", diags)
-//		}
-//	}
-//
-//	return &sqlserverflexbeta.CreateUserRequestPayload{
-//		DefaultDatabase: model.DefaultDatabase.ValueStringPointer(),
-//		Username:        model.Username.ValueStringPointer(),
-//		Roles:           &roles,
-//	}, nil
-//}

stackit/internal/services/sqlserverflexbeta/user/mapper.go

@@ -0,0 +1,179 @@
+package sqlserverflexbeta
+
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/hashicorp/terraform-plugin-framework/attr"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"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"
+)
+
+// mapDataSourceFields maps the API response to a dataSourceModel.
+func mapDataSourceFields(userResp *sqlserverflexbeta.GetUserResponse, model *dataSourceModel, region string) error {
+	if userResp == nil {
+		return fmt.Errorf("response is nil")
+	}
+	if model == nil {
+		return fmt.Errorf("model input is nil")
+	}
+	user := userResp
+
+	// Handle user ID
+	var userId int64
+	if model.UserId.ValueInt64() != 0 {
+		userId = model.UserId.ValueInt64()
+	} else if user.Id != nil {
+		userId = *user.Id
+	} else {
+		return fmt.Errorf("user id not present")
+	}
+
+	// Set main attributes
+	model.Id = utils.BuildInternalTerraformId(
+		model.ProjectId.ValueString(), region, model.InstanceId.ValueString(), strconv.FormatInt(userId, 10),
+	)
+	model.UserId = types.Int64Value(userId)
+	model.Username = types.StringPointerValue(user.Username)
+
+	// Map roles
+	if user.Roles == nil {
+		model.Roles = types.List(types.SetNull(types.StringType))
+	} else {
+		var roles []attr.Value
+		for _, role := range *user.Roles {
+			roles = append(roles, types.StringValue(string(role)))
+		}
+		rolesSet, diags := types.SetValue(types.StringType, roles)
+		if diags.HasError() {
+			return fmt.Errorf("failed to map roles: %w", core.DiagsToError(diags))
+		}
+		model.Roles = types.List(rolesSet)
+	}
+
+	// Set remaining attributes
+	model.Host = types.StringPointerValue(user.Host)
+	model.Port = types.Int64PointerValue(user.Port)
+	model.Region = types.StringValue(region)
+	model.Status = types.StringPointerValue(user.Status)
+	model.DefaultDatabase = types.StringPointerValue(user.DefaultDatabase)
+
+	return nil
+}
+
+// mapFields maps the API response to a resourceModel.
+func mapFields(userResp *sqlserverflexbeta.GetUserResponse, model *resourceModel, region string) error {
+	if userResp == nil {
+		return fmt.Errorf("response is nil")
+	}
+	if model == nil {
+		return fmt.Errorf("model input is nil")
+	}
+	user := userResp
+
+	// Handle user ID
+	var userId int64
+	if model.UserId.ValueInt64() != 0 {
+		userId = model.UserId.ValueInt64()
+	} else if user.Id != nil {
+		userId = *user.Id
+	} else {
+		return fmt.Errorf("user id not present")
+	}
+
+	// Set main attributes
+	model.Id = types.Int64Value(userId)
+	model.UserId = types.Int64Value(userId)
+	model.Username = types.StringPointerValue(user.Username)
+
+	// Map roles
+	if user.Roles != nil {
+		var roles []attr.Value
+		for _, role := range *user.Roles {
+			roles = append(roles, types.StringValue(string(role)))
+		}
+		rolesSet, diags := types.SetValue(types.StringType, roles)
+		if diags.HasError() {
+			return fmt.Errorf("failed to map roles: %w", core.DiagsToError(diags))
+		}
+		model.Roles = types.List(rolesSet)
+	}
+
+	// Ensure roles is not null
+	if model.Roles.IsNull() || model.Roles.IsUnknown() {
+		model.Roles = types.List(types.SetNull(types.StringType))
+	}
+
+	// Set connection details
+	model.Host = types.StringPointerValue(user.Host)
+	model.Port = types.Int64PointerValue(user.Port)
+	model.Region = types.StringValue(region)
+	return nil
+}
+
+// mapFieldsCreate maps the API response from creating a user to a resourceModel.
+func mapFieldsCreate(userResp *sqlserverflexbeta.CreateUserResponse, model *resourceModel, region string) error {
+	if userResp == nil {
+		return fmt.Errorf("response is nil")
+	}
+	if model == nil {
+		return fmt.Errorf("model input is nil")
+	}
+	user := userResp
+
+	if user.Id == nil {
+		return fmt.Errorf("user id not present")
+	}
+	userId := *user.Id
+	model.Id = types.Int64Value(userId)
+	model.UserId = types.Int64Value(userId)
+	model.Username = types.StringPointerValue(user.Username)
+
+	if user.Password == nil {
+		return fmt.Errorf("user password not present")
+	}
+	model.Password = types.StringValue(*user.Password)
+
+	if user.Roles != nil {
+		var roles []attr.Value
+		for _, role := range *user.Roles {
+			roles = append(roles, types.StringValue(string(role)))
+		}
+		rolesSet, diags := types.SetValue(types.StringType, roles)
+		if diags.HasError() {
+			return fmt.Errorf("failed to map roles: %w", core.DiagsToError(diags))
+		}
+		model.Roles = types.List(rolesSet)
+	}
+
+	if model.Roles.IsNull() || model.Roles.IsUnknown() {
+		model.Roles = types.List(types.SetNull(types.StringType))
+	}
+
+	model.Host = types.StringPointerValue(user.Host)
+	model.Port = types.Int64PointerValue(user.Port)
+	model.Region = types.StringValue(region)
+	model.Status = types.StringPointerValue(user.Status)
+	model.DefaultDatabase = types.StringPointerValue(user.DefaultDatabase)
+
+	return nil
+}
+
+// toCreatePayload converts a resourceModel to an API CreateUserRequestPayload.
+func toCreatePayload(
+	model *resourceModel,
+	roles []sqlserverflexbeta.UserRole,
+) (*sqlserverflexbeta.CreateUserRequestPayload, error) {
+	if model == nil {
+		return nil, fmt.Errorf("nil model")
+	}
+
+	return &sqlserverflexbeta.CreateUserRequestPayload{
+		Username:        conversion.StringValueToPointer(model.Username),
+		DefaultDatabase: conversion.StringValueToPointer(model.DefaultDatabase),
+		Roles:           &roles,
+	}, nil
+}

stackit/internal/services/sqlserverflexbeta/user/mapper_test.go

@@ -0,0 +1,527 @@
+package sqlserverflexbeta
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/hashicorp/terraform-plugin-framework/attr"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/stackitcloud/stackit-sdk-go/core/utils"
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/pkg_gen/sqlserverflexbeta"
+)
+
+func TestMapDataSourceFields(t *testing.T) {
+	const testRegion = "region"
+	tests := []struct {
+		description string
+		input       *sqlserverflexbeta.GetUserResponse
+		region      string
+		expected    dataSourceModel
+		isValid     bool
+	}{
+		{
+			"default_values",
+			&sqlserverflexbeta.GetUserResponse{},
+			testRegion,
+			dataSourceModel{
+				Id:              types.StringValue("pid,region,iid,1"),
+				UserId:          types.Int64Value(1),
+				InstanceId:      types.StringValue("iid"),
+				ProjectId:       types.StringValue("pid"),
+				Username:        types.StringNull(),
+				Roles:           types.List(types.SetNull(types.StringType)),
+				Host:            types.StringNull(),
+				Port:            types.Int64Null(),
+				Region:          types.StringValue(testRegion),
+				Status:          types.StringNull(),
+				DefaultDatabase: types.StringNull(),
+			},
+			true,
+		},
+		{
+			"simple_values",
+			&sqlserverflexbeta.GetUserResponse{
+
+				Roles: &[]sqlserverflexbeta.UserRole{
+					"role_1",
+					"role_2",
+					"",
+				},
+				Username:        utils.Ptr("username"),
+				Host:            utils.Ptr("host"),
+				Port:            utils.Ptr(int64(1234)),
+				Status:          utils.Ptr("active"),
+				DefaultDatabase: utils.Ptr("default_db"),
+			},
+			testRegion,
+			dataSourceModel{
+				Id:         types.StringValue("pid,region,iid,1"),
+				UserId:     types.Int64Value(1),
+				InstanceId: types.StringValue("iid"),
+				ProjectId:  types.StringValue("pid"),
+				Username:   types.StringValue("username"),
+				Roles: types.List(
+					types.SetValueMust(
+						types.StringType, []attr.Value{
+							types.StringValue("role_1"),
+							types.StringValue("role_2"),
+							types.StringValue(""),
+						},
+					),
+				),
+				Host:            types.StringValue("host"),
+				Port:            types.Int64Value(1234),
+				Region:          types.StringValue(testRegion),
+				Status:          types.StringValue("active"),
+				DefaultDatabase: types.StringValue("default_db"),
+			},
+			true,
+		},
+		{
+			"null_fields_and_int_conversions",
+			&sqlserverflexbeta.GetUserResponse{
+				Id:       utils.Ptr(int64(1)),
+				Roles:    &[]sqlserverflexbeta.UserRole{},
+				Username: nil,
+				Host:     nil,
+				Port:     utils.Ptr(int64(2123456789)),
+			},
+			testRegion,
+			dataSourceModel{
+				Id:         types.StringValue("pid,region,iid,1"),
+				UserId:     types.Int64Value(1),
+				InstanceId: types.StringValue("iid"),
+				ProjectId:  types.StringValue("pid"),
+				Username:   types.StringNull(),
+				Roles:      types.List(types.SetValueMust(types.StringType, []attr.Value{})),
+				Host:       types.StringNull(),
+				Port:       types.Int64Value(2123456789),
+				Region:     types.StringValue(testRegion),
+			},
+			true,
+		},
+		{
+			"nil_response",
+			nil,
+			testRegion,
+			dataSourceModel{},
+			false,
+		},
+		{
+			"nil_response_2",
+			&sqlserverflexbeta.GetUserResponse{},
+			testRegion,
+			dataSourceModel{},
+			false,
+		},
+		{
+			"no_resource_id",
+			&sqlserverflexbeta.GetUserResponse{},
+			testRegion,
+			dataSourceModel{},
+			false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(
+			tt.description, func(t *testing.T) {
+				state := &dataSourceModel{
+					ProjectId:  tt.expected.ProjectId,
+					InstanceId: tt.expected.InstanceId,
+					UserId:     tt.expected.UserId,
+				}
+				err := mapDataSourceFields(tt.input, state, tt.region)
+				if !tt.isValid && err == nil {
+					t.Fatalf("Should have failed")
+				}
+				if tt.isValid && err != nil {
+					t.Fatalf("Should not have failed: %v", err)
+				}
+				if tt.isValid {
+					diff := cmp.Diff(state, &tt.expected)
+					if diff != "" {
+						t.Fatalf("Data does not match: %s", diff)
+					}
+				}
+			},
+		)
+	}
+}
+
+func TestMapFieldsCreate(t *testing.T) {
+	const testRegion = "region"
+	tests := []struct {
+		description string
+		input       *sqlserverflexbeta.CreateUserResponse
+		region      string
+		expected    resourceModel
+		isValid     bool
+	}{
+		{
+			"default_values",
+			&sqlserverflexbeta.CreateUserResponse{
+				Id:       utils.Ptr(int64(1)),
+				Password: utils.Ptr(""),
+			},
+			testRegion,
+			resourceModel{
+				Id:         types.Int64Value(1),
+				UserId:     types.Int64Value(1),
+				InstanceId: types.StringValue("iid"),
+				ProjectId:  types.StringValue("pid"),
+				Username:   types.StringNull(),
+				Roles:      types.List(types.SetNull(types.StringType)),
+				Password:   types.StringValue(""),
+				Host:       types.StringNull(),
+				Port:       types.Int64Null(),
+				Region:     types.StringValue(testRegion),
+			},
+			true,
+		},
+		{
+			"simple_values",
+			&sqlserverflexbeta.CreateUserResponse{
+				Id: utils.Ptr(int64(2)),
+				Roles: &[]sqlserverflexbeta.UserRole{
+					"role_1",
+					"role_2",
+					"",
+				},
+				Username:        utils.Ptr("username"),
+				Password:        utils.Ptr("password"),
+				Host:            utils.Ptr("host"),
+				Port:            utils.Ptr(int64(1234)),
+				Status:          utils.Ptr("status"),
+				DefaultDatabase: utils.Ptr("default_db"),
+			},
+			testRegion,
+			resourceModel{
+				Id:         types.Int64Value(2),
+				UserId:     types.Int64Value(2),
+				InstanceId: types.StringValue("iid"),
+				ProjectId:  types.StringValue("pid"),
+				Username:   types.StringValue("username"),
+				Roles: types.List(
+					types.SetValueMust(
+						types.StringType, []attr.Value{
+							types.StringValue("role_1"),
+							types.StringValue("role_2"),
+							types.StringValue(""),
+						},
+					),
+				),
+				Password:        types.StringValue("password"),
+				Host:            types.StringValue("host"),
+				Port:            types.Int64Value(1234),
+				Region:          types.StringValue(testRegion),
+				Status:          types.StringValue("status"),
+				DefaultDatabase: types.StringValue("default_db"),
+			},
+			true,
+		},
+		{
+			"null_fields_and_int_conversions",
+			&sqlserverflexbeta.CreateUserResponse{
+				Id:       utils.Ptr(int64(3)),
+				Roles:    &[]sqlserverflexbeta.UserRole{},
+				Username: nil,
+				Password: utils.Ptr(""),
+				Host:     nil,
+				Port:     utils.Ptr(int64(2123456789)),
+			},
+			testRegion,
+			resourceModel{
+				Id:              types.Int64Value(3),
+				UserId:          types.Int64Value(3),
+				InstanceId:      types.StringValue("iid"),
+				ProjectId:       types.StringValue("pid"),
+				Username:        types.StringNull(),
+				Roles:           types.List(types.SetValueMust(types.StringType, []attr.Value{})),
+				Password:        types.StringValue(""),
+				Host:            types.StringNull(),
+				Port:            types.Int64Value(2123456789),
+				Region:          types.StringValue(testRegion),
+				DefaultDatabase: types.StringNull(),
+				Status:          types.StringNull(),
+			},
+			true,
+		},
+		{
+			"nil_response",
+			nil,
+			testRegion,
+			resourceModel{},
+			false,
+		},
+		{
+			"nil_response_2",
+			&sqlserverflexbeta.CreateUserResponse{},
+			testRegion,
+			resourceModel{},
+			false,
+		},
+		{
+			"no_resource_id",
+			&sqlserverflexbeta.CreateUserResponse{},
+			testRegion,
+			resourceModel{},
+			false,
+		},
+		{
+			"no_password",
+			&sqlserverflexbeta.CreateUserResponse{
+				Id: utils.Ptr(int64(1)),
+			},
+			testRegion,
+			resourceModel{},
+			false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(
+			tt.description, func(t *testing.T) {
+				state := &resourceModel{
+					ProjectId:  tt.expected.ProjectId,
+					InstanceId: tt.expected.InstanceId,
+				}
+				err := mapFieldsCreate(tt.input, state, tt.region)
+				if !tt.isValid && err == nil {
+					t.Fatalf("Should have failed")
+				}
+				if tt.isValid && err != nil {
+					t.Fatalf("Should not have failed: %v", err)
+				}
+				if tt.isValid {
+					diff := cmp.Diff(state, &tt.expected)
+					if diff != "" {
+						t.Fatalf("Data does not match: %s", diff)
+					}
+				}
+			},
+		)
+	}
+}
+
+func TestMapFields(t *testing.T) {
+	const testRegion = "region"
+	tests := []struct {
+		description string
+		input       *sqlserverflexbeta.GetUserResponse
+		region      string
+		expected    resourceModel
+		isValid     bool
+	}{
+		{
+			"default_values",
+			&sqlserverflexbeta.GetUserResponse{},
+			testRegion,
+			resourceModel{
+				Id:         types.Int64Value(1),
+				UserId:     types.Int64Value(1),
+				InstanceId: types.StringValue("iid"),
+				ProjectId:  types.StringValue("pid"),
+				Username:   types.StringNull(),
+				Roles:      types.List(types.SetNull(types.StringType)),
+				Host:       types.StringNull(),
+				Port:       types.Int64Null(),
+				Region:     types.StringValue(testRegion),
+			},
+			true,
+		},
+		{
+			"simple_values",
+			&sqlserverflexbeta.GetUserResponse{
+				Roles: &[]sqlserverflexbeta.UserRole{
+					"role_1",
+					"role_2",
+					"",
+				},
+				Username: utils.Ptr("username"),
+				Host:     utils.Ptr("host"),
+				Port:     utils.Ptr(int64(1234)),
+			},
+			testRegion,
+			resourceModel{
+				Id:         types.Int64Value(2),
+				UserId:     types.Int64Value(2),
+				InstanceId: types.StringValue("iid"),
+				ProjectId:  types.StringValue("pid"),
+				Username:   types.StringValue("username"),
+				Roles: types.List(
+					types.SetValueMust(
+						types.StringType, []attr.Value{
+							types.StringValue("role_1"),
+							types.StringValue("role_2"),
+							types.StringValue(""),
+						},
+					),
+				),
+				Host:   types.StringValue("host"),
+				Port:   types.Int64Value(1234),
+				Region: types.StringValue(testRegion),
+			},
+			true,
+		},
+		{
+			"null_fields_and_int_conversions",
+			&sqlserverflexbeta.GetUserResponse{
+				Id:       utils.Ptr(int64(1)),
+				Roles:    &[]sqlserverflexbeta.UserRole{},
+				Username: nil,
+				Host:     nil,
+				Port:     utils.Ptr(int64(2123456789)),
+			},
+			testRegion,
+			resourceModel{
+				Id:         types.Int64Value(1),
+				UserId:     types.Int64Value(1),
+				InstanceId: types.StringValue("iid"),
+				ProjectId:  types.StringValue("pid"),
+				Username:   types.StringNull(),
+				Roles:      types.List(types.SetValueMust(types.StringType, []attr.Value{})),
+				Host:       types.StringNull(),
+				Port:       types.Int64Value(2123456789),
+				Region:     types.StringValue(testRegion),
+			},
+			true,
+		},
+		{
+			"nil_response",
+			nil,
+			testRegion,
+			resourceModel{},
+			false,
+		},
+		{
+			"nil_response_2",
+			&sqlserverflexbeta.GetUserResponse{},
+			testRegion,
+			resourceModel{},
+			false,
+		},
+		{
+			"no_resource_id",
+			&sqlserverflexbeta.GetUserResponse{},
+			testRegion,
+			resourceModel{},
+			false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(
+			tt.description, func(t *testing.T) {
+				state := &resourceModel{
+					ProjectId:  tt.expected.ProjectId,
+					InstanceId: tt.expected.InstanceId,
+					UserId:     tt.expected.UserId,
+				}
+				err := mapFields(tt.input, state, tt.region)
+				if !tt.isValid && err == nil {
+					t.Fatalf("Should have failed")
+				}
+				if tt.isValid && err != nil {
+					t.Fatalf("Should not have failed: %v", err)
+				}
+				if tt.isValid {
+					diff := cmp.Diff(state, &tt.expected)
+					if diff != "" {
+						t.Fatalf("Data does not match: %s", diff)
+					}
+				}
+			},
+		)
+	}
+}
+
+func TestToCreatePayload(t *testing.T) {
+	tests := []struct {
+		description string
+		input       *resourceModel
+		inputRoles  []sqlserverflexbeta.UserRole
+		expected    *sqlserverflexbeta.CreateUserRequestPayload
+		isValid     bool
+	}{
+		{
+			"default_values",
+			&resourceModel{},
+			[]sqlserverflexbeta.UserRole{},
+			&sqlserverflexbeta.CreateUserRequestPayload{
+				Roles:    &[]sqlserverflexbeta.UserRole{},
+				Username: nil,
+			},
+			true,
+		},
+		{
+			"default_values",
+			&resourceModel{
+				Username: types.StringValue("username"),
+			},
+			[]sqlserverflexbeta.UserRole{
+				"role_1",
+				"role_2",
+			},
+			&sqlserverflexbeta.CreateUserRequestPayload{
+				Roles: &[]sqlserverflexbeta.UserRole{
+					"role_1",
+					"role_2",
+				},
+				Username: utils.Ptr("username"),
+			},
+			true,
+		},
+		{
+			"null_fields_and_int_conversions",
+			&resourceModel{
+				Username: types.StringNull(),
+			},
+			[]sqlserverflexbeta.UserRole{
+				"",
+			},
+			&sqlserverflexbeta.CreateUserRequestPayload{
+				Roles: &[]sqlserverflexbeta.UserRole{
+					"",
+				},
+				Username: nil,
+			},
+			true,
+		},
+		{
+			"nil_model",
+			nil,
+			[]sqlserverflexbeta.UserRole{},
+			nil,
+			false,
+		},
+		{
+			"nil_roles",
+			&resourceModel{
+				Username: types.StringValue("username"),
+			},
+			[]sqlserverflexbeta.UserRole{},
+			&sqlserverflexbeta.CreateUserRequestPayload{
+				Roles:    &[]sqlserverflexbeta.UserRole{},
+				Username: utils.Ptr("username"),
+			},
+			true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(
+			tt.description, func(t *testing.T) {
+				output, err := toCreatePayload(tt.input, tt.inputRoles)
+				if !tt.isValid && err == nil {
+					t.Fatalf("Should have failed")
+				}
+				if tt.isValid && err != nil {
+					t.Fatalf("Should not have failed: %v", err)
+				}
+				if tt.isValid {
+					diff := cmp.Diff(output, tt.expected)
+					if diff != "" {
+						t.Fatalf("Data does not match: %s", diff)
+					}
+				}
+			},
+		)
+	}
+}

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

@@ -3,7 +3,9 @@ package sqlserverflexbeta
 import (
 	"context"
 	_ "embed"
+	"errors"
 	"fmt"
+	"net/http"
 	"strconv"
 	"strings"
 
@@ -12,9 +14,12 @@ import (
 	"github.com/hashicorp/terraform-plugin-framework/resource/identityschema"
 	"github.com/hashicorp/terraform-plugin-framework/types"
 	"github.com/hashicorp/terraform-plugin-log/tflog"
-	"github.com/stackitcloud/stackit-sdk-go/core/config"
+	"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"
+	sqlserverflexbetagen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/user/resources_gen"
+	sqlserverflexbetaUtils "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/utils"
+	sqlserverflexbetaWait "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/wait/sqlserverflexbeta"
 
 	"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"
@@ -54,319 +59,20 @@ func (r *userResource) Metadata(ctx context.Context, req resource.MetadataReques
 	resp.TypeName = req.ProviderTypeName + "_sqlserverflexbeta_user"
 }
 
-//go:embed planModifiers.yaml
-var modifiersFileByte []byte
-
-func (r *userResource) Schema(ctx context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
-
-	s := sqlserverflexbetaResGen.UserResourceSchema(ctx)
-
-	fields, err := utils.ReadModifiersConfig(modifiersFileByte)
-	if err != nil {
-		resp.Diagnostics.AddError("error during read modifiers config file", err.Error())
-		return
-	}
-
-	err = utils.AddPlanModifiersToResourceSchema(fields, &s)
-	if err != nil {
-		resp.Diagnostics.AddError("error adding plan modifiers", err.Error())
-		return
-	}
-	resp.Schema = s
-}
-
-func (r *userResource) IdentitySchema(
-	_ context.Context,
-	_ resource.IdentitySchemaRequest,
-	resp *resource.IdentitySchemaResponse,
-) {
-	resp.IdentitySchema = identityschema.Schema{
-		Attributes: map[string]identityschema.Attribute{
-			"project_id": identityschema.StringAttribute{
-				RequiredForImport: true, // must be set during import by the practitioner
-			},
-			"region": identityschema.StringAttribute{
-				RequiredForImport: true, // can be defaulted by the provider configuration
-			},
-			"instance_id": identityschema.StringAttribute{
-				RequiredForImport: true, // can be defaulted by the provider configuration
-			},
-		},
-	}
-}
-
 // Configure adds the provider configured client to the resource.
-func (r *userResource) Configure(
-	ctx context.Context,
-	req resource.ConfigureRequest,
-	resp *resource.ConfigureResponse,
-) {
+func (r *userResource) Configure(ctx context.Context, req resource.ConfigureRequest, resp *resource.ConfigureResponse) {
 	var ok bool
 	r.providerData, ok = conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
 	if !ok {
 		return
 	}
 
-	apiClientConfigOptions := []config.ConfigurationOption{
-		config.WithCustomAuth(r.providerData.RoundTripper),
-		utils.UserAgentConfigOption(r.providerData.Version),
-	}
-	if r.providerData.SQLServerFlexCustomEndpoint != "" {
-		apiClientConfigOptions = append(
-			apiClientConfigOptions,
-			config.WithEndpoint(r.providerData.SQLServerFlexCustomEndpoint),
-		)
-	} else {
-		apiClientConfigOptions = append(apiClientConfigOptions, config.WithRegion(r.providerData.GetRegion()))
-	}
-	apiClient, err := sqlserverflexbeta.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,
-			),
-		)
+	apiClient := sqlserverflexbetaUtils.ConfigureClient(ctx, &r.providerData, &resp.Diagnostics)
+	if resp.Diagnostics.HasError() {
 		return
 	}
 	r.client = apiClient
-	tflog.Info(ctx, "sqlserverflexbeta.User client configured")
-}
-
-func (r *userResource) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) {
-	var data resourceModel
-
-	// Read Terraform plan data into the model
-	resp.Diagnostics.Append(req.Plan.Get(ctx, &data)...)
-
-	if resp.Diagnostics.HasError() {
-		return
-	}
-
-	// Read identity data
-	var identityData UserResourceIdentityModel
-	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)
-
-	//payload, err := toCreatePayload(ctx, &data)
-	//if err != nil {
-	//	core.LogAndAddError(
-	//		ctx,
-	//		&resp.Diagnostics,
-	//		"Error creating User",
-	//		fmt.Sprintf("Creating API payload: %v", err),
-	//	)
-	//	return
-	//}
-	//payload = payload
-
-	// TODO: Create API call logic
-	/*
-				// Generate API request body from model
-		    	payload, err := toCreatePayload(ctx, &model)
-		    	if err != nil {
-		    		core.LogAndAddError(
-		    			ctx,
-		    			&resp.Diagnostics,
-		    			"Error creating User",
-		    			fmt.Sprintf("Creating API payload: %v", err),
-		    		)
-		    		return
-		    	}
-		    	// Create new User
-		    	createResp, err := r.client.CreateUserRequest(
-		    		ctx,
-		    		projectId,
-		    		region,
-		    	).CreateUserRequestPayload(*payload).Execute()
-		    	if err != nil {
-		    		core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating User", fmt.Sprintf("Calling API: %v", err))
-		    		return
-		    	}
-
-		    	ctx = core.LogResponse(ctx)
-
-		    	UserId := *createResp.Id
-	*/
-
-	// Example data value setting
-	//data.UserId = types.StringValue("id-from-response")
-
-	// TODO: Set data returned by API in identity
-	identity := UserResourceIdentityModel{
-		ProjectID: types.StringValue(projectId),
-		Region:    types.StringValue(region),
-		// TODO: add missing values
-		//	UserID: types.StringValue(UserId),
-	}
-	resp.Diagnostics.Append(resp.Identity.Set(ctx, identity)...)
-	if resp.Diagnostics.HasError() {
-		return
-	}
-
-	// TODO: implement wait handler if needed
-	/*
-
-				waitResp, err := wait.CreateUserWaitHandler(
-		    		ctx,
-		    		r.client,
-		    		projectId,
-		    		UserId,
-		    		region,
-		    	).SetSleepBeforeWait(
-		    		30 * time.Second,
-		    	).SetTimeout(
-		    		90 * time.Minute,
-		    	).WaitWithContext(ctx)
-		    	if err != nil {
-		    		core.LogAndAddError(
-		    			ctx,
-		    			&resp.Diagnostics,
-		    			"Error creating User",
-		    			fmt.Sprintf("User creation waiting: %v", err),
-		    		)
-		    		return
-		    	}
-
-		    	if waitResp.Id == nil {
-		    		core.LogAndAddError(
-		    			ctx,
-		    			&resp.Diagnostics,
-		    			"Error creating User",
-		    			"User creation waiting: returned id is nil",
-		    		)
-		    		return
-		    	}
-
-		    	// Map response body to schema
-		    	err = mapResponseToModel(ctx, waitResp, &model, resp.Diagnostics)
-		    	if err != nil {
-		    		core.LogAndAddError(
-		    			ctx,
-		    			&resp.Diagnostics,
-		    			"Error creating User",
-		    			fmt.Sprintf("Processing API payload: %v", err),
-		    		)
-		    		return
-		    	}
-
-	*/
-
-	// Save data into Terraform state
-	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
-
-	tflog.Info(ctx, "sqlserverflexbeta.User created")
-}
-
-func (r *userResource) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse) {
-	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 UserResourceIdentityModel
-	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: Read API call logic
-
-	// Save updated data into Terraform state
-	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
-
-	// TODO: Set data returned by API in identity
-	identity := UserResourceIdentityModel{
-		ProjectID: types.StringValue(projectId),
-		Region:    types.StringValue(region),
-		// InstanceID: types.StringValue(instanceId),
-	}
-	resp.Diagnostics.Append(resp.Identity.Set(ctx, identity)...)
-	if resp.Diagnostics.HasError() {
-		return
-	}
-
-	tflog.Info(ctx, "sqlserverflexbeta.User read")
-}
-
-func (r *userResource) 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 UserResourceIdentityModel
-	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.User updated")
-}
-
-func (r *userResource) 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)...)
-	if resp.Diagnostics.HasError() {
-		return
-	}
-
-	// Read identity data
-	var identityData UserResourceIdentityModel
-	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: Delete API call logic
-
-	tflog.Info(ctx, "sqlserverflexbeta.User deleted")
+	tflog.Info(ctx, "SQLServer Beta Flex user client configured")
 }
 
 // ModifyPlan implements resource.ResourceWithModifyPlan.
@@ -397,25 +103,256 @@ func (r *userResource) ModifyPlan(
 		return
 	}
 
-	var identityModel UserResourceIdentityModel
-	identityModel.ProjectID = planModel.ProjectId
-	identityModel.Region = planModel.Region
-	// TODO: complete
-	//if !planModel.InstanceId.IsNull() && !planModel.InstanceId.IsUnknown() {
-	//	identityModel.InstanceID = planModel.InstanceId
-	//}
-
-	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
 	}
 }
 
+//go:embed planModifiers.yaml
+var modifiersFileByte []byte
+
+// Schema defines the schema for the resource.
+func (r *userResource) Schema(ctx context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
+	s := sqlserverflexbetagen.UserResourceSchema(ctx)
+
+	fields, err := utils.ReadModifiersConfig(modifiersFileByte)
+	if err != nil {
+		resp.Diagnostics.AddError("error during read modifiers config file", err.Error())
+		return
+	}
+
+	err = utils.AddPlanModifiersToResourceSchema(fields, &s)
+	if err != nil {
+		resp.Diagnostics.AddError("error adding plan modifiers", err.Error())
+		return
+	}
+	resp.Schema = s
+}
+
+// IdentitySchema defines the schema for the resource's identity attributes.
+func (r *userResource) IdentitySchema(
+	_ context.Context,
+	_ resource.IdentitySchemaRequest,
+	response *resource.IdentitySchemaResponse,
+) {
+	response.IdentitySchema = identityschema.Schema{
+		Attributes: map[string]identityschema.Attribute{
+			"project_id": identityschema.StringAttribute{
+				RequiredForImport: true, // must be set during import by the practitioner
+			},
+			"region": identityschema.StringAttribute{
+				RequiredForImport: true, // can be defaulted by the provider configuration
+			},
+			"instance_id": identityschema.StringAttribute{
+				RequiredForImport: true, // can be defaulted by the provider configuration
+			},
+			"user_id": identityschema.Int64Attribute{
+				RequiredForImport: true, // can be defaulted by the provider configuration
+			},
+		},
+	}
+}
+
+// Create creates the resource and sets the initial Terraform state.
+func (r *userResource) Create(
+	ctx context.Context,
+	req resource.CreateRequest,
+	resp *resource.CreateResponse,
+) { // nolint:gocritic // function signature required by Terraform
+	var model resourceModel
+	diags := req.Plan.Get(ctx, &model)
+	resp.Diagnostics.Append(diags...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	ctx = core.InitProviderContext(ctx)
+
+	projectId := model.ProjectId.ValueString()
+	instanceId := model.InstanceId.ValueString()
+	region := model.Region.ValueString()
+
+	ctx = tflog.SetField(ctx, "project_id", projectId)
+	ctx = tflog.SetField(ctx, "instance_id", instanceId)
+	ctx = tflog.SetField(ctx, "region", region)
+
+	var roles []sqlserverflexbeta.UserRole
+	if !model.Roles.IsNull() && !model.Roles.IsUnknown() {
+		diags = model.Roles.ElementsAs(ctx, &roles, false)
+		resp.Diagnostics.Append(diags...)
+		if resp.Diagnostics.HasError() {
+			return
+		}
+	}
+
+	// Generate API request body from model
+	payload, err := toCreatePayload(&model, roles)
+	if err != nil {
+		core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating user", fmt.Sprintf("Creating API payload: %v", err))
+		return
+	}
+	// Create new user
+	userResp, err := r.client.CreateUserRequest(
+		ctx,
+		projectId,
+		region,
+		instanceId,
+	).CreateUserRequestPayload(*payload).Execute()
+	if err != nil {
+		core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating user", fmt.Sprintf("Calling API: %v", err))
+		return
+	}
+
+	ctx = core.LogResponse(ctx)
+
+	if userResp == nil || userResp.Id == nil || *userResp.Id == 0 {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"Error creating user",
+			"API didn't return user Id. A user might have been created",
+		)
+		return
+	}
+	userId := *userResp.Id
+	ctx = tflog.SetField(ctx, "user_id", userId)
+
+	// Map response body to schema
+	err = mapFieldsCreate(userResp, &model, region)
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"Error creating user",
+			fmt.Sprintf("Processing API payload: %v", err),
+		)
+		return
+	}
+	// Set state to fully populated data
+	diags = resp.State.Set(ctx, model)
+	resp.Diagnostics.Append(diags...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	tflog.Info(ctx, "SQLServer Flex user created")
+}
+
+// Read refreshes the Terraform state with the latest data.
+func (r *userResource) Read(
+	ctx context.Context,
+	req resource.ReadRequest,
+	resp *resource.ReadResponse,
+) { // 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
+	}
+
+	ctx = core.InitProviderContext(ctx)
+
+	projectId := model.ProjectId.ValueString()
+	instanceId := model.InstanceId.ValueString()
+	userId := model.UserId.ValueInt64()
+	region := r.providerData.GetRegionWithOverride(model.Region)
+	ctx = tflog.SetField(ctx, "project_id", projectId)
+	ctx = tflog.SetField(ctx, "instance_id", instanceId)
+	ctx = tflog.SetField(ctx, "user_id", userId)
+	ctx = tflog.SetField(ctx, "region", region)
+
+	recordSetResp, err := r.client.GetUserRequest(ctx, projectId, region, instanceId, userId).Execute()
+	if err != nil {
+		var oapiErr *oapierror.GenericOpenAPIError
+		ok := errors.As(
+			err,
+			&oapiErr,
+		)
+		//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 {
+			resp.State.RemoveResource(ctx)
+			return
+		}
+		core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading user", fmt.Sprintf("Calling API: %v", err))
+		return
+	}
+
+	ctx = core.LogResponse(ctx)
+
+	// Map response body to schema
+	err = mapFields(recordSetResp, &model, region)
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"Error reading user",
+			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
+	}
+	tflog.Info(ctx, "SQLServer Flex user read")
+}
+
+// Update updates the resource and sets the updated Terraform state on success.
+func (r *userResource) Update(
+	ctx context.Context,
+	_ resource.UpdateRequest,
+	resp *resource.UpdateResponse,
+) { // nolint:gocritic // function signature required by Terraform
+	// Update shouldn't be called
+	core.LogAndAddError(ctx, &resp.Diagnostics, "Error updating user", "User can't be updated")
+}
+
+// Delete deletes the resource and removes the Terraform state on success.
+func (r *userResource) Delete(
+	ctx context.Context,
+	req resource.DeleteRequest,
+	resp *resource.DeleteResponse,
+) { // nolint:gocritic // function signature required by Terraform
+	// Retrieve values from plan
+	var model resourceModel
+	diags := req.State.Get(ctx, &model)
+	resp.Diagnostics.Append(diags...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	ctx = core.InitProviderContext(ctx)
+
+	projectId := model.ProjectId.ValueString()
+	instanceId := model.InstanceId.ValueString()
+	userId := model.UserId.ValueInt64()
+	region := model.Region.ValueString()
+	ctx = tflog.SetField(ctx, "project_id", projectId)
+	ctx = tflog.SetField(ctx, "instance_id", instanceId)
+	ctx = tflog.SetField(ctx, "user_id", userId)
+	ctx = tflog.SetField(ctx, "region", region)
+
+	// Delete existing record set
+	// err := r.client.DeleteUserRequest(ctx, projectId, region, instanceId, userId).Execute()
+
+	// Delete existing record set
+	_, err := sqlserverflexbetaWait.DeleteUserWaitHandler(ctx, r.client, projectId, region, instanceId, userId).
+		WaitWithContext(ctx)
+	//err := r.client.DeleteUserRequest(ctx, arg.projectId, arg.region, arg.instanceId, userId).Execute()
+	if err != nil {
+		core.LogAndAddError(ctx, &resp.Diagnostics, "User Delete Error", fmt.Sprintf("Calling API: %v", err))
+		return
+	}
+
+	ctx = core.LogResponse(ctx)
+
+	tflog.Info(ctx, "SQLServer Flex user deleted")
+}
+
 // ImportState imports a resource into the Terraform state on success.
 // The expected format of the resource import identifier is: project_id,zone_id,record_set_id
 func (r *userResource) ImportState(
@@ -423,6 +360,7 @@ func (r *userResource) ImportState(
 	req resource.ImportStateRequest,
 	resp *resource.ImportStateResponse,
 ) {
+
 	ctx = core.InitProviderContext(ctx)
 
 	if req.ID != "" {
@@ -457,7 +395,7 @@ func (r *userResource) ImportState(
 		resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("instance_id"), idParts[2])...)
 		resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("user_id"), userId)...)
 
-		tflog.Info(ctx, "Sqlserverflexbeta user state imported")
+		tflog.Info(ctx, "Postgres Flex user state imported")
 
 		return
 	}
@@ -482,9 +420,8 @@ func (r *userResource) ImportState(
 	core.LogAndAddWarning(
 		ctx,
 		&resp.Diagnostics,
-		"Sqlserverflexbeta 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.",
+		"SQLServer Flex user imported with empty password",
+		"The user password is not imported as it is only available upon creation of a new user. The password field will be empty.",
 	)
-	tflog.Info(ctx, "Sqlserverflexbeta user state imported")
-
+	tflog.Info(ctx, "SQLServer Flex user state imported")
 }