feat: initial copy of v0.1.0

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

@@ -1,71 +1,64 @@
-// Copyright (c) STACKIT
-
 package sqlserverflexalpha
 
 import (
 	"context"
+	_ "embed"
 	"errors"
 	"fmt"
 	"net/http"
+	"slices"
 	"strconv"
 	"strings"
+	"time"
 
-	"github.com/stackitcloud/terraform-provider-stackit/pkg/sqlserverflexalpha"
-	sqlserverflexalphaUtils "github.com/stackitcloud/terraform-provider-stackit/stackit/internal/services/sqlserverflexalpha/utils"
-
-	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
-	"github.com/hashicorp/terraform-plugin-log/tflog"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/conversion"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/utils"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/validate"
-
-	"github.com/hashicorp/terraform-plugin-framework/attr"
 	"github.com/hashicorp/terraform-plugin-framework/path"
 	"github.com/hashicorp/terraform-plugin-framework/resource"
-	"github.com/hashicorp/terraform-plugin-framework/resource/schema"
-	"github.com/hashicorp/terraform-plugin-framework/resource/schema/planmodifier"
-	"github.com/hashicorp/terraform-plugin-framework/resource/schema/setplanmodifier"
-	"github.com/hashicorp/terraform-plugin-framework/resource/schema/stringplanmodifier"
+	"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/oapierror"
+
+	sqlserverflexalpha "github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3alpha1api"
+
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/conversion"
+	sqlserverflexalphaUtils "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/utils"
+	sqlserverflexalphaWait "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"
+
+	sqlserverflexalphaResGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/user/resources_gen"
 )
 
-// Ensure the implementation satisfies the expected interfaces.
 var (
-	_ resource.Resource                = &userResource{}
-	_ resource.ResourceWithConfigure   = &userResource{}
-	_ resource.ResourceWithImportState = &userResource{}
-	_ resource.ResourceWithModifyPlan  = &userResource{}
+	_ resource.Resource                   = &userResource{}
+	_ resource.ResourceWithConfigure      = &userResource{}
+	_ resource.ResourceWithImportState    = &userResource{}
+	_ resource.ResourceWithModifyPlan     = &userResource{}
+	_ resource.ResourceWithIdentity       = &userResource{}
+	_ resource.ResourceWithValidateConfig = &userResource{}
 )
 
-type Model struct {
-	Id              types.String `tfsdk:"id"` // needed by TF
-	UserId          types.Int64  `tfsdk:"user_id"`
-	InstanceId      types.String `tfsdk:"instance_id"`
-	ProjectId       types.String `tfsdk:"project_id"`
-	Username        types.String `tfsdk:"username"`
-	Roles           types.Set    `tfsdk:"roles"`
-	Password        types.String `tfsdk:"password"`
-	Host            types.String `tfsdk:"host"`
-	Port            types.Int64  `tfsdk:"port"`
-	Region          types.String `tfsdk:"region"`
-	Status          types.String `tfsdk:"status"`
-	DefaultDatabase types.String `tfsdk:"default_database"`
-}
-
-// NewUserResource is a helper function to simplify the provider implementation.
 func NewUserResource() resource.Resource {
 	return &userResource{}
 }
 
-// userResource is the resource implementation.
+// resourceModel describes the resource data model.
+type resourceModel = sqlserverflexalphaResGen.UserModel
+
+// UserResourceIdentityModel describes the resource's identity attributes.
+type UserResourceIdentityModel struct {
+	ProjectID  types.String `tfsdk:"project_id"`
+	Region     types.String `tfsdk:"region"`
+	InstanceID types.String `tfsdk:"instance_id"`
+	UserID     types.Int64  `tfsdk:"user_id"`
+}
+
 type userResource struct {
 	client       *sqlserverflexalpha.APIClient
 	providerData core.ProviderData
 }
 
-// Metadata returns the resource type name.
 func (r *userResource) Metadata(_ context.Context, req resource.MetadataRequest, resp *resource.MetadataResponse) {
 	resp.TypeName = req.ProviderTypeName + "_sqlserverflexalpha_user"
 }
@@ -93,7 +86,7 @@ func (r *userResource) ModifyPlan(
 	req resource.ModifyPlanRequest,
 	resp *resource.ModifyPlanResponse,
 ) { // nolint:gocritic // function signature required by Terraform
-	var configModel Model
+	var configModel resourceModel
 	// skip initial empty configuration to avoid follow-up errors
 	if req.Config.Raw.IsNull() {
 		return
@@ -103,7 +96,7 @@ func (r *userResource) ModifyPlan(
 		return
 	}
 
-	var planModel Model
+	var planModel resourceModel
 	resp.Diagnostics.Append(req.Plan.Get(ctx, &planModel)...)
 	if resp.Diagnostics.HasError() {
 		return
@@ -120,118 +113,91 @@ func (r *userResource) ModifyPlan(
 	}
 }
 
+//go:embed planModifiers.yaml
+var modifiersFileByte []byte
+
 // Schema defines the schema for the resource.
-func (r *userResource) Schema(_ context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
-	descriptions := map[string]string{
-		"main":             "SQLServer Flex user resource schema. Must have a `region` specified in the provider configuration.",
-		"id":               "Terraform's internal resource ID. It is structured as \"`project_id`,`region`,`instance_id`,`user_id`\".",
-		"user_id":          "User ID.",
-		"instance_id":      "ID of the SQLServer Flex instance.",
-		"project_id":       "STACKIT project ID to which the instance is associated.",
-		"username":         "Username of the SQLServer Flex instance.",
-		"roles":            "Database access levels for the user. The values for the default roles are: `##STACKIT_DatabaseManager##`, `##STACKIT_LoginManager##`, `##STACKIT_ProcessManager##`, `##STACKIT_ServerManager##`, `##STACKIT_SQLAgentManager##`, `##STACKIT_SQLAgentUser##`",
-		"password":         "Password of the user account.",
-		"status":           "Status of the user.",
-		"default_database": "Default database of the user.",
+func (r *userResource) Schema(ctx context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
+	s := sqlserverflexalphaResGen.UserResourceSchema(ctx)
+
+	fields, err := utils.ReadModifiersConfig(modifiersFileByte)
+	if err != nil {
+		resp.Diagnostics.AddError("error during read modifiers config file", err.Error())
+		return
 	}
 
-	resp.Schema = schema.Schema{
-		Description: descriptions["main"],
-		Attributes: map[string]schema.Attribute{
-			"id": schema.StringAttribute{
-				Description: descriptions["id"],
-				Computed:    true,
-				PlanModifiers: []planmodifier.String{
-					stringplanmodifier.UseStateForUnknown(),
-				},
+	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
 			},
-			"user_id": schema.StringAttribute{
-				Description: descriptions["user_id"],
-				Computed:    true,
-				PlanModifiers: []planmodifier.String{
-					stringplanmodifier.UseStateForUnknown(),
-				},
-				Validators: []validator.String{
-					validate.NoSeparator(),
-				},
+			"region": identityschema.StringAttribute{
+				RequiredForImport: true, // can be defaulted by the provider configuration
 			},
-			"instance_id": schema.StringAttribute{
-				Description: descriptions["instance_id"],
-				Required:    true,
-				PlanModifiers: []planmodifier.String{
-					stringplanmodifier.RequiresReplace(),
-					stringplanmodifier.UseStateForUnknown(),
-				},
-				Validators: []validator.String{
-					validate.UUID(),
-					validate.NoSeparator(),
-				},
+			"instance_id": identityschema.StringAttribute{
+				RequiredForImport: true, // can be defaulted by the provider configuration
 			},
-			"project_id": schema.StringAttribute{
-				Description: descriptions["project_id"],
-				Required:    true,
-				PlanModifiers: []planmodifier.String{
-					stringplanmodifier.RequiresReplace(),
-					stringplanmodifier.UseStateForUnknown(),
-				},
-				Validators: []validator.String{
-					validate.UUID(),
-					validate.NoSeparator(),
-				},
-			},
-			"username": schema.StringAttribute{
-				Description: descriptions["username"],
-				Required:    true,
-				PlanModifiers: []planmodifier.String{
-					stringplanmodifier.RequiresReplace(),
-					stringplanmodifier.UseStateForUnknown(),
-				},
-			},
-			"roles": schema.SetAttribute{
-				Description: descriptions["roles"],
-				ElementType: types.StringType,
-				Required:    true,
-				PlanModifiers: []planmodifier.Set{
-					setplanmodifier.RequiresReplace(),
-				},
-			},
-			"password": schema.StringAttribute{
-				Description: descriptions["password"],
-				Computed:    true,
-				Sensitive:   true,
-			},
-			"host": schema.StringAttribute{
-				Computed: true,
-			},
-			"port": schema.Int64Attribute{
-				Computed: true,
-			},
-			"region": schema.StringAttribute{
-				Optional: true,
-				// must be computed to allow for storing the override value from the provider
-				Computed:    true,
-				Description: descriptions["region"],
-				PlanModifiers: []planmodifier.String{
-					stringplanmodifier.RequiresReplace(),
-				},
-			},
-			"status": schema.StringAttribute{
-				Computed: true,
-			},
-			"default_database": schema.StringAttribute{
-				Computed: true,
+			"user_id": identityschema.Int64Attribute{
+				RequiredForImport: true, // can be defaulted by the provider configuration
 			},
 		},
 	}
 }
 
+func (r *userResource) ValidateConfig(
+	ctx context.Context,
+	req resource.ValidateConfigRequest,
+	resp *resource.ValidateConfigResponse,
+) {
+	var data resourceModel
+
+	resp.Diagnostics.Append(req.Config.Get(ctx, &data)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	var roles []string
+	diags := data.Roles.ElementsAs(ctx, &roles, false)
+	resp.Diagnostics.Append(diags...)
+	if diags.HasError() {
+		return
+	}
+
+	var resRoles []string
+	for _, role := range roles {
+		if slices.Contains(resRoles, role) {
+			resp.Diagnostics.AddAttributeError(
+				path.Root("roles"),
+				"Attribute Configuration Error",
+				"defined roles MUST NOT contain duplicates",
+			)
+			return
+		}
+		resRoles = append(resRoles, role)
+	}
+}
+
 // 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 Model
+	var model resourceModel
 	diags := req.Plan.Get(ctx, &model)
 	resp.Diagnostics.Append(diags...)
 	if resp.Diagnostics.HasError() {
@@ -240,21 +206,23 @@ func (r *userResource) Create(
 
 	ctx = core.InitProviderContext(ctx)
 
-	projectId := model.ProjectId.ValueString()
-	instanceId := model.InstanceId.ValueString()
+	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, "project_id", projectID)
+	ctx = tflog.SetField(ctx, "instance_id", instanceID)
 	ctx = tflog.SetField(ctx, "region", region)
 
-	var roles []sqlserverflexalpha.UserRole
-	if !(model.Roles.IsNull() || model.Roles.IsUnknown()) {
+	var roles []string
+	if !model.Roles.IsNull() && !model.Roles.IsUnknown() {
 		diags = model.Roles.ElementsAs(ctx, &roles, false)
 		resp.Diagnostics.Append(diags...)
 		if resp.Diagnostics.HasError() {
 			return
 		}
+
+		slices.Sort(roles)
 	}
 
 	// Generate API request body from model
@@ -264,11 +232,11 @@ func (r *userResource) Create(
 		return
 	}
 	// Create new user
-	userResp, err := r.client.CreateUserRequest(
+	userResp, err := r.client.DefaultAPI.CreateUserRequest(
 		ctx,
-		projectId,
+		projectID,
 		region,
-		instanceId,
+		instanceID,
 	).CreateUserRequestPayload(*payload).Execute()
 	if err != nil {
 		core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating user", fmt.Sprintf("Calling API: %v", err))
@@ -277,7 +245,7 @@ func (r *userResource) Create(
 
 	ctx = core.LogResponse(ctx)
 
-	if userResp == nil || userResp.Id == nil || *userResp.Id == 0 {
+	if userResp == nil || userResp.Id == 0 {
 		core.LogAndAddError(
 			ctx,
 			&resp.Diagnostics,
@@ -286,10 +254,22 @@ func (r *userResource) Create(
 		)
 		return
 	}
-	userId := *userResp.Id
+
+	userId := userResp.Id
 	ctx = tflog.SetField(ctx, "user_id", userId)
 
-	// Map response body to schema
+	// Set data returned by API in identity
+	identity := UserResourceIdentityModel{
+		ProjectID:  types.StringValue(projectID),
+		Region:     types.StringValue(region),
+		InstanceID: types.StringValue(instanceID),
+		UserID:     types.Int64Value(userId),
+	}
+	resp.Diagnostics.Append(resp.Identity.Set(ctx, identity)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
 	err = mapFieldsCreate(userResp, &model, region)
 	if err != nil {
 		core.LogAndAddError(
@@ -300,6 +280,51 @@ func (r *userResource) Create(
 		)
 		return
 	}
+
+	waitResp, err := sqlserverflexalphaWait.CreateUserWaitHandler(
+		ctx,
+		r.client.DefaultAPI,
+		projectID,
+		instanceID,
+		region,
+		userId,
+	).SetSleepBeforeWait(
+		90 * time.Second,
+	).SetTimeout(
+		90 * time.Minute,
+	).WaitWithContext(ctx)
+
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"create user",
+			fmt.Sprintf("Instance creation waiting: %v", err),
+		)
+		return
+	}
+
+	if waitResp.Id == 0 {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"create user",
+			"Instance creation waiting: returned id is nil",
+		)
+		return
+	}
+
+	// Map response body to schema
+	err = mapFields(waitResp, &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...)
@@ -315,7 +340,7 @@ func (r *userResource) Read(
 	req resource.ReadRequest,
 	resp *resource.ReadResponse,
 ) { // nolint:gocritic // function signature required by Terraform
-	var model Model
+	var model resourceModel
 	diags := req.State.Get(ctx, &model)
 	resp.Diagnostics.Append(diags...)
 	if resp.Diagnostics.HasError() {
@@ -333,7 +358,7 @@ func (r *userResource) Read(
 	ctx = tflog.SetField(ctx, "user_id", userId)
 	ctx = tflog.SetField(ctx, "region", region)
 
-	recordSetResp, err := r.client.GetUserRequest(ctx, projectId, region, instanceId, userId).Execute()
+	recordSetResp, err := r.client.DefaultAPI.GetUserRequest(ctx, projectId, region, instanceId, userId).Execute()
 	if err != nil {
 		var oapiErr *oapierror.GenericOpenAPIError
 		ok := errors.As(
@@ -363,6 +388,18 @@ func (r *userResource) Read(
 		return
 	}
 
+	// Set data returned by API in identity
+	identity := UserResourceIdentityModel{
+		ProjectID:  types.StringValue(projectId),
+		Region:     types.StringValue(region),
+		InstanceID: types.StringValue(instanceId),
+		UserID:     types.Int64Value(userId),
+	}
+	resp.Diagnostics.Append(resp.Identity.Set(ctx, identity)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
 	// Set refreshed state
 	diags = resp.State.Set(ctx, model)
 	resp.Diagnostics.Append(diags...)
@@ -389,7 +426,7 @@ func (r *userResource) Delete(
 	resp *resource.DeleteResponse,
 ) { // nolint:gocritic // function signature required by Terraform
 	// Retrieve values from plan
-	var model Model
+	var model resourceModel
 	diags := req.State.Get(ctx, &model)
 	resp.Diagnostics.Append(diags...)
 	if resp.Diagnostics.HasError() {
@@ -408,14 +445,40 @@ func (r *userResource) Delete(
 	ctx = tflog.SetField(ctx, "region", region)
 
 	// Delete existing record set
-	err := r.client.DeleteUserRequest(ctx, projectId, region, instanceId, userId).Execute()
+	// err := r.client.DeleteUserRequest(ctx, projectId, region, instanceId, userId).Execute()
+	err := r.client.DefaultAPI.DeleteUserRequest(ctx, projectId, region, instanceId, userId).Execute()
 	if err != nil {
-		core.LogAndAddError(ctx, &resp.Diagnostics, "Error deleting user", fmt.Sprintf("Calling API: %v", err))
+		var oapiErr *oapierror.GenericOpenAPIError
+		ok := errors.As(err, &oapiErr)
+		if !ok {
+			// TODO err handling
+			return
+		}
+
+		switch oapiErr.StatusCode {
+		case http.StatusNotFound:
+			resp.State.RemoveResource(ctx)
+			return
+		// case http.StatusInternalServerError:
+		// 	tflog.Warn(ctx, "[delete user] Wait handler got error 500")
+		// 	return false, nil, nil
+		default:
+			// TODO err handling
+			return
+		}
+	}
+	// Delete existing record set
+	_, err = sqlserverflexalphaWait.DeleteUserWaitHandler(ctx, r.client.DefaultAPI, projectId, region, instanceId, userId).
+		WaitWithContext(ctx)
+	if err != nil {
+		core.LogAndAddError(ctx, &resp.Diagnostics, "User Delete Error", fmt.Sprintf("Calling API: %v", err))
 		return
 	}
 
 	ctx = core.LogResponse(ctx)
 
+	resp.State.RemoveResource(ctx)
+
 	tflog.Info(ctx, "SQLServer Flex user deleted")
 }
 
@@ -426,23 +489,61 @@ func (r *userResource) ImportState(
 	req resource.ImportStateRequest,
 	resp *resource.ImportStateResponse,
 ) {
-	idParts := strings.Split(req.ID, core.Separator)
-	if len(idParts) != 4 || idParts[0] == "" || idParts[1] == "" || idParts[2] == "" || idParts[3] == "" {
-		core.LogAndAddError(
-			ctx, &resp.Diagnostics,
-			"Error importing user",
-			fmt.Sprintf(
-				"Expected import identifier with format [project_id],[region],[instance_id],[user_id], got %q",
-				req.ID,
-			),
-		)
+	ctx = core.InitProviderContext(ctx)
+
+	if req.ID != "" {
+		idParts := strings.Split(req.ID, core.Separator)
+
+		if len(idParts) != 4 || idParts[0] == "" || idParts[1] == "" || idParts[2] == "" || idParts[3] == "" {
+			core.LogAndAddError(
+				ctx, &resp.Diagnostics,
+				"Error importing user",
+				fmt.Sprintf(
+					"Expected import identifier with format [project_id],[region],[instance_id],[user_id], got %q",
+					req.ID,
+				),
+			)
+			return
+		}
+
+		userId, err := strconv.ParseInt(idParts[3], 10, 64)
+		if err != nil {
+			core.LogAndAddError(
+				ctx,
+				&resp.Diagnostics,
+				"Error importing user",
+				fmt.Sprintf("Invalid user_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("user_id"), userId)...)
+
+		tflog.Info(ctx, "SQLServer Flex user state imported")
+
 		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("user_id"), idParts[3])...)
+	// If no ID is provided, attempt to read identity attributes from the import configuration
+	var identityData UserResourceIdentityModel
+	resp.Diagnostics.Append(req.Identity.Get(ctx, &identityData)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	projectId := identityData.ProjectID.ValueString()
+	region := identityData.Region.ValueString()
+	instanceId := identityData.InstanceID.ValueString()
+	userId := identityData.UserID.ValueInt64()
+
+	resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("project_id"), projectId)...)
+	resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("region"), region)...)
+	resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("instance_id"), instanceId)...)
+	resp.Diagnostics.Append(resp.State.SetAttribute(ctx, path.Root("user_id"), userId)...)
+
 	core.LogAndAddWarning(
 		ctx,
 		&resp.Diagnostics,
@@ -451,118 +552,3 @@ func (r *userResource) ImportState(
 	)
 	tflog.Info(ctx, "SQLServer Flex user state imported")
 }
-
-func mapFieldsCreate(userResp *sqlserverflexalpha.CreateUserResponse, model *Model, 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 = utils.BuildInternalTerraformId(
-		model.ProjectId.ValueString(),
-		region,
-		model.InstanceId.ValueString(),
-		strconv.FormatInt(userId, 10),
-	)
-	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 = rolesSet
-	}
-
-	if model.Roles.IsNull() || model.Roles.IsUnknown() {
-		model.Roles = 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
-}
-
-func mapFields(userResp *sqlserverflexalpha.GetUserResponse, model *Model, region string) error {
-	if userResp == nil {
-		return fmt.Errorf("response is nil")
-	}
-	if model == nil {
-		return fmt.Errorf("model input is nil")
-	}
-	user := userResp
-
-	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")
-	}
-	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)
-
-	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 = rolesSet
-	}
-
-	if model.Roles.IsNull() || model.Roles.IsUnknown() {
-		model.Roles = types.SetNull(types.StringType)
-	}
-
-	model.Host = types.StringPointerValue(user.Host)
-	model.Port = types.Int64PointerValue(user.Port)
-	model.Region = types.StringValue(region)
-	return nil
-}
-
-func toCreatePayload(
-	model *Model,
-	roles []sqlserverflexalpha.UserRole,
-) (*sqlserverflexalpha.CreateUserRequestPayload, error) {
-	if model == nil {
-		return nil, fmt.Errorf("nil model")
-	}
-
-	return &sqlserverflexalpha.CreateUserRequestPayload{
-		Username:        conversion.StringValueToPointer(model.Username),
-		DefaultDatabase: conversion.StringValueToPointer(model.DefaultDatabase),
-		Roles:           &roles,
-	}, nil
-}