feat: initial copy of v0.1.0

stackit/internal/services/sqlserverflexalpha/instance/functions.go

@@ -1,430 +1,277 @@
-package sqlserverflex
+package sqlserverflexalpha
 
 import (
 	"context"
+	"errors"
 	"fmt"
-	"strings"
+	"math"
 
 	"github.com/hashicorp/terraform-plugin-framework/attr"
+	"github.com/hashicorp/terraform-plugin-framework/diag"
+	"github.com/hashicorp/terraform-plugin-framework/resource"
 	"github.com/hashicorp/terraform-plugin-framework/types"
-	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
-	sqlserverflex "github.com/stackitcloud/terraform-provider-stackit/pkg/sqlserverflexalpha"
-	"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"
+
+	sqlserverflexalpha "github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3alpha1api"
+
+	sqlserverflexalphaDataGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/instance/datasources_gen"
+	sqlserverflexalphaResGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/instance/resources_gen"
 )
 
-type sqlserverflexClient interface {
-	GetFlavorsRequestExecute(ctx context.Context, projectId, region string, page, size *int64, sort sqlserverflex.FlavorSort) (*sqlserverflex.GetFlavorsResponse, error)
-}
-
-func mapFields(ctx context.Context, resp *sqlserverflex.GetInstanceResponse, model *Model, flavor *flavorModel, storage *storageModel, encryption *encryptionModel, network *networkModel, region string) error {
-	if resp == nil {
-		return fmt.Errorf("response input is nil")
-	}
-	if model == nil {
-		return fmt.Errorf("model input is nil")
-	}
-	instance := resp
-
-	var instanceId string
-	if model.InstanceId.ValueString() != "" {
-		instanceId = model.InstanceId.ValueString()
-	} else if instance.Id != nil {
-		instanceId = *instance.Id
-	} else {
-		return fmt.Errorf("instance id not present")
-	}
-
-	var flavorValues map[string]attr.Value
-	if instance.FlavorId == nil {
-		return fmt.Errorf("instance has no flavor id")
-	}
-	if *instance.FlavorId != flavor.Id.ValueString() {
-		return fmt.Errorf("instance has different flavor id %s - %s", *instance.FlavorId, flavor.Id.ValueString())
-	}
-
-	flavorValues = map[string]attr.Value{
-		"id":          flavor.Id,
-		"description": flavor.Description,
-		"cpu":         flavor.CPU,
-		"ram":         flavor.RAM,
-		"node_type":   flavor.NodeType,
-	}
-	flavorObject, diags := types.ObjectValue(flavorTypes, flavorValues)
+func mapResponseToModel(
+	ctx context.Context,
+	resp *sqlserverflexalpha.GetInstanceResponse,
+	m *sqlserverflexalphaResGen.InstanceModel,
+	tfDiags diag.Diagnostics,
+) error {
+	m.BackupSchedule = types.StringValue(resp.GetBackupSchedule())
+	m.Edition = types.StringValue(string(resp.GetEdition()))
+	m.Encryption = handleEncryption(m, resp)
+	m.FlavorId = types.StringValue(resp.GetFlavorId())
+	m.Id = types.StringValue(resp.GetId())
+	m.InstanceId = types.StringValue(resp.GetId())
+	m.IsDeletable = types.BoolValue(resp.GetIsDeletable())
+	m.Name = types.StringValue(resp.GetName())
+	netAcl, diags := types.ListValueFrom(ctx, types.StringType, resp.Network.GetAcl())
+	tfDiags.Append(diags...)
 	if diags.HasError() {
-		return fmt.Errorf("creating flavor: %w", core.DiagsToError(diags))
+		return fmt.Errorf(
+			"error converting network acl response value",
+		)
 	}
-
-	var storageValues map[string]attr.Value
-	if instance.Storage == nil {
-		storageValues = map[string]attr.Value{
-			"class": storage.Class,
-			"size":  storage.Size,
-		}
-	} else {
-		storageValues = map[string]attr.Value{
-			"class": types.StringValue(*instance.Storage.Class),
-			"size":  types.Int64PointerValue(instance.Storage.Size),
-		}
-	}
-	storageObject, diags := types.ObjectValue(storageTypes, storageValues)
+	net, diags := sqlserverflexalphaResGen.NewNetworkValue(
+		sqlserverflexalphaResGen.NetworkValue{}.AttributeTypes(ctx),
+		map[string]attr.Value{
+			"access_scope":     types.StringValue(string(resp.Network.GetAccessScope())),
+			"acl":              netAcl,
+			"instance_address": types.StringValue(resp.Network.GetInstanceAddress()),
+			"router_address":   types.StringValue(resp.Network.GetRouterAddress()),
+		},
+	)
+	tfDiags.Append(diags...)
 	if diags.HasError() {
-		return fmt.Errorf("creating storage: %w", core.DiagsToError(diags))
+		return errors.New("error converting network response value")
 	}
+	m.Network = net
+	m.Replicas = types.Int64Value(int64(resp.GetReplicas()))
+	m.RetentionDays = types.Int64Value(int64(resp.GetRetentionDays()))
+	m.Status = types.StringValue(string(resp.GetStatus()))
 
-	var encryptionValues map[string]attr.Value
-	if instance.Encryption == nil {
-		encryptionValues = map[string]attr.Value{
-			"keyring_id":      encryption.KeyRingId,
-			"key_id":          encryption.KeyId,
-			"key_version":     encryption.KeyVersion,
-			"service_account": encryption.ServiceAccount,
-		}
-	} else {
-		encryptionValues = map[string]attr.Value{
-			"keyring_id":      types.StringValue(*instance.Encryption.KekKeyRingId),
-			"key_id":          types.StringValue(*instance.Encryption.KekKeyId),
-			"key_version":     types.StringValue(*instance.Encryption.KekKeyVersion),
-			"service_account": types.StringValue(*instance.Encryption.ServiceAccount),
-		}
-	}
-	encryptionObject, diags := types.ObjectValue(encryptionTypes, encryptionValues)
+	stor, diags := sqlserverflexalphaResGen.NewStorageValue(
+		sqlserverflexalphaResGen.StorageValue{}.AttributeTypes(ctx),
+		map[string]attr.Value{
+			"class": types.StringValue(resp.Storage.GetClass()),
+			"size":  types.Int64Value(resp.Storage.GetSize()),
+		},
+	)
+	tfDiags.Append(diags...)
 	if diags.HasError() {
-		return fmt.Errorf("creating encryption: %w", core.DiagsToError(diags))
+		return fmt.Errorf("error converting storage response value")
 	}
+	m.Storage = stor
 
-	var networkValues map[string]attr.Value
-	if instance.Network == nil {
-		networkValues = map[string]attr.Value{
-			"acl":              network.ACL,
-			"access_scope":     network.AccessScope,
-			"instance_address": network.InstanceAddress,
-			"router_address":   network.RouterAddress,
-		}
-	} else {
-		aclList, diags := types.ListValueFrom(ctx, types.StringType, *instance.Network.Acl)
-		if diags.HasError() {
-			return fmt.Errorf("creating network (acl list): %w", core.DiagsToError(diags))
-		}
-
-		var routerAddress string
-		if instance.Network.RouterAddress != nil {
-			routerAddress = *instance.Network.RouterAddress
-			diags.AddWarning("field missing while mapping fields", "router_address was empty in API response")
-		}
-		if instance.Network.InstanceAddress == nil {
-			return fmt.Errorf("creating network: no instance address returned")
-		}
-		networkValues = map[string]attr.Value{
-			"acl":              aclList,
-			"access_scope":     types.StringValue(string(*instance.Network.AccessScope)),
-			"instance_address": types.StringValue(*instance.Network.InstanceAddress),
-			"router_address":   types.StringValue(routerAddress),
-		}
-	}
-	networkObject, diags := types.ObjectValue(networkTypes, networkValues)
-	if diags.HasError() {
-		return fmt.Errorf("creating network: %w", core.DiagsToError(diags))
-	}
-
-	simplifiedModelBackupSchedule := utils.SimplifyBackupSchedule(model.BackupSchedule.ValueString())
-	// If the value returned by the API is different from the one in the model after simplification,
-	// we update the model so that it causes an error in Terraform
-	if simplifiedModelBackupSchedule != types.StringPointerValue(instance.BackupSchedule).ValueString() {
-		model.BackupSchedule = types.StringPointerValue(instance.BackupSchedule)
-	}
-
-	if instance.Replicas == nil {
-		return fmt.Errorf("instance has no replicas set")
-	}
-
-	if instance.RetentionDays == nil {
-		return fmt.Errorf("instance has no retention days set")
-	}
-
-	if instance.Version == nil {
-		return fmt.Errorf("instance has no version set")
-	}
-
-	if instance.Edition == nil {
-		return fmt.Errorf("instance has no edition set")
-	}
-
-	if instance.Status == nil {
-		return fmt.Errorf("instance has no status set")
-	}
-
-	if instance.IsDeletable == nil {
-		return fmt.Errorf("instance has no IsDeletable set")
-	}
-
-	model.Id = utils.BuildInternalTerraformId(model.ProjectId.ValueString(), region, instanceId)
-	model.InstanceId = types.StringValue(instanceId)
-	model.Name = types.StringPointerValue(instance.Name)
-	model.Flavor = flavorObject
-	model.Replicas = types.Int64Value(int64(*instance.Replicas))
-	model.Storage = storageObject
-	model.Version = types.StringValue(string(*instance.Version))
-	model.Edition = types.StringValue(string(*instance.Edition))
-	model.Region = types.StringValue(region)
-	model.Encryption = encryptionObject
-	model.Network = networkObject
-	model.RetentionDays = types.Int64Value(*instance.RetentionDays)
-	model.Status = types.StringValue(string(*instance.Status))
-	model.IsDeletable = types.BoolValue(*instance.IsDeletable)
+	m.Version = types.StringValue(string(resp.GetVersion()))
 	return nil
 }
 
-func toCreatePayload(model *Model, storage *storageModel, encryption *encryptionModel, network *networkModel) (*sqlserverflex.CreateInstanceRequestPayload, error) {
+func mapDataResponseToModel(
+	ctx context.Context,
+	resp *sqlserverflexalpha.GetInstanceResponse,
+	m *dataSourceModel,
+	tfDiags diag.Diagnostics,
+) error {
+	m.BackupSchedule = types.StringValue(resp.GetBackupSchedule())
+	m.Edition = types.StringValue(string(resp.GetEdition()))
+	m.Encryption = handleDSEncryption(m, resp)
+	m.FlavorId = types.StringValue(resp.GetFlavorId())
+	m.Id = types.StringValue(resp.GetId())
+	m.InstanceId = types.StringValue(resp.GetId())
+	m.IsDeletable = types.BoolValue(resp.GetIsDeletable())
+	m.Name = types.StringValue(resp.GetName())
+	netAcl, diags := types.ListValueFrom(ctx, types.StringType, resp.Network.GetAcl())
+	tfDiags.Append(diags...)
+	if diags.HasError() {
+		return fmt.Errorf(
+			"error converting network acl response value",
+		)
+	}
+	net, diags := sqlserverflexalphaDataGen.NewNetworkValue(
+		sqlserverflexalphaDataGen.NetworkValue{}.AttributeTypes(ctx),
+		map[string]attr.Value{
+			"access_scope":     types.StringValue(string(resp.Network.GetAccessScope())),
+			"acl":              netAcl,
+			"instance_address": types.StringValue(resp.Network.GetInstanceAddress()),
+			"router_address":   types.StringValue(resp.Network.GetRouterAddress()),
+		},
+	)
+	tfDiags.Append(diags...)
+	if diags.HasError() {
+		return errors.New("error converting network response value")
+	}
+	m.Network = net
+	m.Replicas = types.Int64Value(int64(resp.GetReplicas()))
+	m.RetentionDays = types.Int64Value(int64(resp.GetRetentionDays()))
+	m.Status = types.StringValue(string(resp.GetStatus()))
+
+	stor, diags := sqlserverflexalphaDataGen.NewStorageValue(
+		sqlserverflexalphaDataGen.StorageValue{}.AttributeTypes(ctx),
+		map[string]attr.Value{
+			"class": types.StringValue(resp.Storage.GetClass()),
+			"size":  types.Int64Value(resp.Storage.GetSize()),
+		},
+	)
+	tfDiags.Append(diags...)
+	if diags.HasError() {
+		return fmt.Errorf("error converting storage response value")
+	}
+	m.Storage = stor
+
+	m.Version = types.StringValue(string(resp.GetVersion()))
+	return nil
+}
+
+func handleEncryption(
+	m *sqlserverflexalphaResGen.InstanceModel,
+	resp *sqlserverflexalpha.GetInstanceResponse,
+) sqlserverflexalphaResGen.EncryptionValue {
+	if !resp.HasEncryption() ||
+		resp.Encryption == nil ||
+		resp.Encryption.KekKeyId == "" ||
+		resp.Encryption.KekKeyRingId == "" ||
+		resp.Encryption.KekKeyVersion == "" ||
+		resp.Encryption.ServiceAccount == "" {
+		if m.Encryption.IsNull() || m.Encryption.IsUnknown() {
+			return sqlserverflexalphaResGen.NewEncryptionValueNull()
+		}
+		return m.Encryption
+	}
+
+	enc := sqlserverflexalphaResGen.NewEncryptionValueNull()
+	if kVal, ok := resp.Encryption.GetKekKeyIdOk(); ok {
+		enc.KekKeyId = types.StringValue(*kVal)
+	}
+	if kkVal, ok := resp.Encryption.GetKekKeyRingIdOk(); ok {
+		enc.KekKeyRingId = types.StringValue(*kkVal)
+	}
+	if kkvVal, ok := resp.Encryption.GetKekKeyVersionOk(); ok {
+		enc.KekKeyVersion = types.StringValue(*kkvVal)
+	}
+	if sa, ok := resp.Encryption.GetServiceAccountOk(); ok {
+		enc.ServiceAccount = types.StringValue(*sa)
+	}
+	return enc
+}
+
+func handleDSEncryption(
+	m *dataSourceModel,
+	resp *sqlserverflexalpha.GetInstanceResponse,
+) sqlserverflexalphaDataGen.EncryptionValue {
+	if !resp.HasEncryption() ||
+		resp.Encryption == nil ||
+		resp.Encryption.KekKeyId == "" ||
+		resp.Encryption.KekKeyRingId == "" ||
+		resp.Encryption.KekKeyVersion == "" ||
+		resp.Encryption.ServiceAccount == "" {
+		if m.Encryption.IsNull() || m.Encryption.IsUnknown() {
+			return sqlserverflexalphaDataGen.NewEncryptionValueNull()
+		}
+		return m.Encryption
+	}
+
+	enc := sqlserverflexalphaDataGen.NewEncryptionValueNull()
+	if kVal, ok := resp.Encryption.GetKekKeyIdOk(); ok {
+		enc.KekKeyId = types.StringValue(*kVal)
+	}
+	if kkVal, ok := resp.Encryption.GetKekKeyRingIdOk(); ok {
+		enc.KekKeyRingId = types.StringValue(*kkVal)
+	}
+	if kkvVal, ok := resp.Encryption.GetKekKeyVersionOk(); ok {
+		enc.KekKeyVersion = types.StringValue(*kkvVal)
+	}
+	if sa, ok := resp.Encryption.GetServiceAccountOk(); ok {
+		enc.ServiceAccount = types.StringValue(*sa)
+	}
+	return enc
+}
+
+func toCreatePayload(
+	ctx context.Context,
+	model *sqlserverflexalphaResGen.InstanceModel,
+) (*sqlserverflexalpha.CreateInstanceRequestPayload, error) {
 	if model == nil {
 		return nil, fmt.Errorf("nil model")
 	}
 
-	if model.Flavor.IsNull() || model.Flavor.IsUnknown() {
-		return nil, fmt.Errorf("nil flavor")
+	storagePayload := sqlserverflexalpha.StorageCreate{}
+	if !model.Storage.IsNull() && !model.Storage.IsUnknown() {
+		storagePayload.Class = model.Storage.Class.ValueString()
+		storagePayload.Size = model.Storage.Size.ValueInt64()
 	}
 
-	storagePayload := &sqlserverflex.CreateInstanceRequestPayloadGetStorageArgType{}
-	if storage != nil {
-		storagePayload.Class = conversion.StringValueToPointer(storage.Class)
-		storagePayload.Size = conversion.Int64ValueToPointer(storage.Size)
-	}
-
-	encryptionPayload := &sqlserverflex.CreateInstanceRequestPayloadGetEncryptionArgType{}
-	if encryption != nil {
-		encryptionPayload.KekKeyId = conversion.StringValueToPointer(encryption.KeyId)
-		encryptionPayload.KekKeyVersion = conversion.StringValueToPointer(encryption.KeyVersion)
-		encryptionPayload.KekKeyRingId = conversion.StringValueToPointer(encryption.KeyRingId)
-		encryptionPayload.ServiceAccount = conversion.StringValueToPointer(encryption.ServiceAccount)
-	}
-
-	networkPayload := &sqlserverflex.CreateInstanceRequestPayloadGetNetworkArgType{}
-	if network != nil {
-		networkPayload.AccessScope = sqlserverflex.CreateInstanceRequestPayloadNetworkGetAccessScopeAttributeType(conversion.StringValueToPointer(network.AccessScope))
-	}
-
-	flavorId := ""
-	if !(model.Flavor.IsNull() || model.Flavor.IsUnknown()) {
-		modelValues := model.Flavor.Attributes()
-		if _, ok := modelValues["id"]; !ok {
-			return nil, fmt.Errorf("flavor has not yet been created")
+	var encryptionPayload *sqlserverflexalpha.InstanceEncryption = nil
+	if !model.Encryption.IsNull() && !model.Encryption.IsUnknown() &&
+		!model.Encryption.KekKeyId.IsNull() && model.Encryption.KekKeyId.IsUnknown() && model.Encryption.KekKeyId.ValueString() != "" &&
+		!model.Encryption.KekKeyRingId.IsNull() && !model.Encryption.KekKeyRingId.IsUnknown() && model.Encryption.KekKeyRingId.ValueString() != "" &&
+		!model.Encryption.KekKeyVersion.IsNull() && !model.Encryption.KekKeyVersion.IsUnknown() && model.Encryption.KekKeyVersion.ValueString() != "" &&
+		!model.Encryption.ServiceAccount.IsNull() && !model.Encryption.ServiceAccount.IsUnknown() && model.Encryption.ServiceAccount.ValueString() != "" {
+		encryptionPayload = &sqlserverflexalpha.InstanceEncryption{
+			KekKeyId:       model.Encryption.KekKeyId.ValueString(),
+			KekKeyRingId:   model.Encryption.KekKeyVersion.ValueString(),
+			KekKeyVersion:  model.Encryption.KekKeyRingId.ValueString(),
+			ServiceAccount: model.Encryption.ServiceAccount.ValueString(),
 		}
-		flavorId = strings.Trim(modelValues["id"].String(), "\"")
 	}
 
-	var aclElements []string
-	if network != nil && !(network.ACL.IsNull() || network.ACL.IsUnknown()) {
-		aclElements = make([]string, 0, len(network.ACL.Elements()))
-		diags := network.ACL.ElementsAs(nil, &aclElements, false)
+	networkPayload := sqlserverflexalpha.CreateInstanceRequestPayloadNetwork{}
+	if !model.Network.IsNull() && !model.Network.IsUnknown() {
+		networkPayload.AccessScope = (*sqlserverflexalpha.InstanceNetworkAccessScope)(model.Network.AccessScope.ValueStringPointer())
+
+		var resList []string
+		diags := model.Network.Acl.ElementsAs(ctx, &resList, false)
 		if diags.HasError() {
-			return nil, fmt.Errorf("creating network: %w", core.DiagsToError(diags))
+			return nil, fmt.Errorf("error converting network acl list")
 		}
+		networkPayload.Acl = resList
 	}
 
-	return &sqlserverflex.CreateInstanceRequestPayload{
-		Acl:            &aclElements,
-		BackupSchedule: conversion.StringValueToPointer(model.BackupSchedule),
-		FlavorId:       &flavorId,
-		Name:           conversion.StringValueToPointer(model.Name),
-		Storage:        storagePayload,
-		Version:        sqlserverflex.CreateInstanceRequestPayloadGetVersionAttributeType(conversion.StringValueToPointer(model.Version)),
+	return &sqlserverflexalpha.CreateInstanceRequestPayload{
+		BackupSchedule: model.BackupSchedule.ValueString(),
 		Encryption:     encryptionPayload,
-		RetentionDays:  conversion.Int64ValueToPointer(model.RetentionDays),
+		FlavorId:       model.FlavorId.ValueString(),
+		Name:           model.Name.ValueString(),
 		Network:        networkPayload,
+		RetentionDays:  int32(model.RetentionDays.ValueInt64()), //nolint:gosec // TODO
+		Storage:        storagePayload,
+		Version:        sqlserverflexalpha.InstanceVersion(model.Version.ValueString()),
 	}, nil
 }
 
-func toUpdatePayload(model *Model, storage *storageModel, network *networkModel) (*sqlserverflex.UpdateInstancePartiallyRequestPayload, error) {
-	if model == nil {
+func toUpdatePayload(
+	ctx context.Context,
+	m *sqlserverflexalphaResGen.InstanceModel,
+	resp *resource.UpdateResponse,
+) (*sqlserverflexalpha.UpdateInstanceRequestPayload, error) {
+	if m == nil {
 		return nil, fmt.Errorf("nil model")
 	}
-	if model.Flavor.IsNull() || model.Flavor.IsUnknown() {
-		return nil, fmt.Errorf("nil flavor")
-	}
-	var flavorMdl flavorModel
-	diag := model.Flavor.As(context.Background(), &flavorMdl, basetypes.ObjectAsOptions{
-		UnhandledNullAsEmpty:    true,
-		UnhandledUnknownAsEmpty: false,
-	})
-	if diag.HasError() {
-		return nil, fmt.Errorf("flavor conversion error: %v", diag.Errors())
+	if m.Replicas.ValueInt64() > math.MaxUint32 {
+		return nil, fmt.Errorf("replicas value is too big for uint32")
 	}
+	replVal := sqlserverflexalpha.Replicas(uint32(m.Replicas.ValueInt64())) // nolint:gosec // check is performed above
 
-	storagePayload := &sqlserverflex.UpdateInstanceRequestPayloadGetStorageArgType{}
-	if storage != nil {
-		storagePayload.Size = conversion.Int64ValueToPointer(storage.Size)
+	var netAcl []string
+	diags := m.Network.Acl.ElementsAs(ctx, &netAcl, false)
+	resp.Diagnostics.Append(diags...)
+	if diags.HasError() {
+		return nil, fmt.Errorf("error converting model network acl value")
 	}
-
-	var aclElements []string
-	if network != nil && !(network.ACL.IsNull() || network.ACL.IsUnknown()) {
-		aclElements = make([]string, 0, len(network.ACL.Elements()))
-		diags := network.ACL.ElementsAs(nil, &aclElements, false)
-		if diags.HasError() {
-			return nil, fmt.Errorf("creating network: %w", core.DiagsToError(diags))
-		}
-	}
-
-	// TODO - implement network.ACL as soon as it becomes available
-	replCount := int32(model.Replicas.ValueInt64())
-	flavorId := flavorMdl.Id.ValueString()
-	return &sqlserverflex.UpdateInstancePartiallyRequestPayload{
-		Acl:            &aclElements,
-		BackupSchedule: conversion.StringValueToPointer(model.BackupSchedule),
-		FlavorId:       &flavorId,
-		Name:           conversion.StringValueToPointer(model.Name),
-		Replicas:       sqlserverflex.UpdateInstancePartiallyRequestPayloadGetReplicasAttributeType(&replCount),
-		RetentionDays:  conversion.Int64ValueToPointer(model.RetentionDays),
-		Storage:        storagePayload,
-		Version:        sqlserverflex.UpdateInstancePartiallyRequestPayloadGetVersionAttributeType(conversion.StringValueToPointer(model.Version)),
+	return &sqlserverflexalpha.UpdateInstanceRequestPayload{
+		BackupSchedule: m.BackupSchedule.ValueString(),
+		FlavorId:       m.FlavorId.ValueString(),
+		Name:           m.Name.ValueString(),
+		Network:        sqlserverflexalpha.UpdateInstanceRequestPayloadNetwork{Acl: netAcl},
+		Replicas:       replVal,
+		RetentionDays:  int32(m.RetentionDays.ValueInt64()), //nolint:gosec // TODO
+		Storage:        sqlserverflexalpha.StorageUpdate{Size: m.Storage.Size.ValueInt64Pointer()},
+		Version:        sqlserverflexalpha.InstanceVersion(m.Version.ValueString()),
 	}, nil
 }
-
-func getAllFlavors(ctx context.Context, client sqlserverflexClient, projectId, region string) ([]sqlserverflex.ListFlavors, error) {
-	if projectId == "" || region == "" {
-		return nil, fmt.Errorf("listing sqlserverflex flavors: projectId and region are required")
-	}
-	var flavorList []sqlserverflex.ListFlavors
-
-	page := int64(1)
-	size := int64(10)
-	for {
-		res, err := client.GetFlavorsRequestExecute(ctx, projectId, region, &page, &size, sqlserverflex.FLAVORSORT_INDEX_ASC)
-		if err != nil {
-			return nil, fmt.Errorf("listing sqlserverflex flavors: %w", err)
-		}
-		if res.Flavors == nil {
-			return nil, fmt.Errorf("finding flavors for project %s", projectId)
-		}
-		pagination := res.GetPagination()
-		flavorList = append(flavorList, *res.Flavors...)
-
-		if *pagination.TotalRows == int64(len(flavorList)) {
-			break
-		}
-		page++
-	}
-	return flavorList, nil
-}
-
-func loadFlavorId(ctx context.Context, client sqlserverflexClient, model *Model, flavor *flavorModel, storage *storageModel) error {
-	if model == nil {
-		return fmt.Errorf("nil model")
-	}
-	if flavor == nil {
-		return fmt.Errorf("nil flavor")
-	}
-	cpu := conversion.Int64ValueToPointer(flavor.CPU)
-	if cpu == nil {
-		return fmt.Errorf("nil CPU")
-	}
-	ram := conversion.Int64ValueToPointer(flavor.RAM)
-	if ram == nil {
-		return fmt.Errorf("nil RAM")
-	}
-	nodeType := conversion.StringValueToPointer(flavor.NodeType)
-	if nodeType == nil {
-		return fmt.Errorf("nil NodeType")
-	}
-	storageClass := conversion.StringValueToPointer(storage.Class)
-	if storageClass == nil {
-		return fmt.Errorf("nil StorageClass")
-	}
-	storageSize := conversion.Int64ValueToPointer(storage.Size)
-	if storageSize == nil {
-		return fmt.Errorf("nil StorageSize")
-	}
-
-	projectId := model.ProjectId.ValueString()
-	region := model.Region.ValueString()
-
-	flavorList, err := getAllFlavors(ctx, client, projectId, region)
-	if err != nil {
-		return err
-	}
-
-	avl := ""
-	foundFlavorCount := 0
-	for _, f := range flavorList {
-		if f.Id == nil || f.Cpu == nil || f.Memory == nil {
-			continue
-		}
-		if strings.ToLower(*f.NodeType) != strings.ToLower(*nodeType) {
-			continue
-		}
-		if *f.Cpu == *cpu && *f.Memory == *ram {
-			var useSc *sqlserverflex.FlavorStorageClassesStorageClass
-			for _, sc := range *f.StorageClasses {
-				if *sc.Class != *storageClass {
-					continue
-				}
-				if *storageSize < *f.MinGB || *storageSize > *f.MaxGB {
-					return fmt.Errorf("storage size %d out of bounds (min: %d - max: %d)", *storageSize, *f.MinGB, *f.MaxGB)
-				}
-				useSc = &sc
-			}
-			if useSc == nil {
-				return fmt.Errorf("no storage class found for %s", *storageClass)
-			}
-
-			flavor.Id = types.StringValue(*f.Id)
-			flavor.Description = types.StringValue(*f.Description)
-			foundFlavorCount++
-		}
-		for _, cls := range *f.StorageClasses {
-			avl = fmt.Sprintf("%s\n- %d CPU, %d GB RAM, storage %s (min: %d - max: %d)", avl, *f.Cpu, *f.Memory, *cls.Class, *f.MinGB, *f.MaxGB)
-		}
-	}
-	if foundFlavorCount > 1 {
-		return fmt.Errorf("multiple flavors found: %d flavors", foundFlavorCount)
-	}
-	if flavor.Id.ValueString() == "" {
-		return fmt.Errorf("couldn't find flavor, available specs are:%s", avl)
-	}
-
-	return nil
-}
-
-func getFlavorModelById(ctx context.Context, client sqlserverflexClient, model *Model, flavor *flavorModel) error {
-	if model == nil {
-		return fmt.Errorf("nil model")
-	}
-	if flavor == nil {
-		return fmt.Errorf("nil flavor")
-	}
-	id := conversion.StringValueToPointer(flavor.Id)
-	if id == nil {
-		return fmt.Errorf("nil flavor ID")
-	}
-
-	flavor.Id = types.StringValue("")
-
-	projectId := model.ProjectId.ValueString()
-	region := model.Region.ValueString()
-
-	flavorList, err := getAllFlavors(ctx, client, projectId, region)
-	if err != nil {
-		return err
-	}
-
-	avl := ""
-	for _, f := range flavorList {
-		if f.Id == nil || f.Cpu == nil || f.Memory == nil {
-			continue
-		}
-		if *f.Id == *id {
-			flavor.Id = types.StringValue(*f.Id)
-			flavor.Description = types.StringValue(*f.Description)
-			flavor.CPU = types.Int64Value(*f.Cpu)
-			flavor.RAM = types.Int64Value(*f.Memory)
-			flavor.NodeType = types.StringValue(*f.NodeType)
-			break
-		}
-		avl = fmt.Sprintf("%s\n- %d CPU, %d GB RAM", avl, *f.Cpu, *f.Memory)
-	}
-	if flavor.Id.ValueString() == "" {
-		return fmt.Errorf("couldn't find flavor, available specs are: %s", avl)
-	}
-
-	return nil
-}