terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/instance/functions.go

package sqlserverflexbeta

import (
	"context"
	"errors"
	"fmt"
	"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"

	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/utils"

	"github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3beta1api"

	sqlserverflexbetaDataGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/instance/datasources_gen"
	sqlserverflexbetaResGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/instance/resources_gen"
)

func mapResponseToModel(
	ctx context.Context,
	resp *v3beta1api.GetInstanceResponse,
	m *sqlserverflexbetaResGen.InstanceModel,
	tfDiags diag.Diagnostics,
) error {
	m.BackupSchedule = types.StringValue(resp.GetBackupSchedule())
	m.Edition = types.StringValue(string(resp.GetEdition()))
	m.Encryption = handleEncryption(ctx, m, resp)
	m.FlavorId = types.StringValue(resp.GetFlavorId())
	m.Id = utils.BuildInternalTerraformId(m.ProjectId.ValueString(), m.Region.ValueString(), 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 := sqlserverflexbetaResGen.NewNetworkValue(
		sqlserverflexbetaResGen.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 := sqlserverflexbetaResGen.NewStorageValue(
		sqlserverflexbetaResGen.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 mapDataResponseToModel(
	ctx context.Context,
	resp *v3beta1api.GetInstanceResponse,
	m *dataSourceModel,
	tfDiags diag.Diagnostics,
) error {
	m.BackupSchedule = types.StringValue(resp.GetBackupSchedule())
	m.Edition = types.StringValue(string(resp.GetEdition()))
	m.Encryption = handleDSEncryption(ctx, 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 := sqlserverflexbetaDataGen.NewNetworkValue(
		sqlserverflexbetaDataGen.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 := sqlserverflexbetaDataGen.NewStorageValue(
		sqlserverflexbetaDataGen.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(
	ctx context.Context,
	m *sqlserverflexbetaResGen.InstanceModel,
	resp *v3beta1api.GetInstanceResponse,
) sqlserverflexbetaResGen.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 sqlserverflexbetaResGen.NewEncryptionValueNull()
		}
		return m.Encryption
	}

	enc := sqlserverflexbetaResGen.NewEncryptionValueMust(
		sqlserverflexbetaResGen.EncryptionValue{}.AttributeTypes(ctx),
		map[string]attr.Value{
			"kek_key_id":      types.StringValue(resp.Encryption.GetKekKeyId()),
			"kek_key_ring_id": types.StringValue(resp.Encryption.GetKekKeyRingId()),
			"kek_key_version": types.StringValue(resp.Encryption.GetKekKeyVersion()),
			"service_account": types.StringValue(resp.Encryption.GetServiceAccount()),
		},
	)
	return enc
}

func handleDSEncryption(
	ctx context.Context,
	m *dataSourceModel,
	resp *v3beta1api.GetInstanceResponse,
) sqlserverflexbetaDataGen.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 sqlserverflexbetaDataGen.NewEncryptionValueNull()
		}
		return m.Encryption
	}

	enc := sqlserverflexbetaDataGen.NewEncryptionValueMust(
		sqlserverflexbetaDataGen.EncryptionValue{}.AttributeTypes(ctx),
		map[string]attr.Value{
			"kek_key_id":      types.StringValue(resp.Encryption.GetKekKeyId()),
			"kek_key_ring_id": types.StringValue(resp.Encryption.GetKekKeyRingId()),
			"kek_key_version": types.StringValue(resp.Encryption.GetKekKeyVersion()),
			"service_account": types.StringValue(resp.Encryption.GetServiceAccount()),
		},
	)
	return enc
}

func toCreatePayload(
	ctx context.Context,
	model *sqlserverflexbetaResGen.InstanceModel,
) (*v3beta1api.CreateInstanceRequestPayload, error) {
	if model == nil {
		return nil, fmt.Errorf("nil model")
	}

	storagePayload := v3beta1api.StorageCreate{}
	if !model.Storage.IsNull() && !model.Storage.IsUnknown() {
		storagePayload.Class = model.Storage.Class.ValueString()
		storagePayload.Size = model.Storage.Size.ValueInt64()
	}

	var encryptionPayload *v3beta1api.InstanceEncryption = nil
	if !model.Encryption.IsNull() && !model.Encryption.IsUnknown() {
		encryptionPayload = &v3beta1api.InstanceEncryption{}
		encryptionPayload.KekKeyId = model.Encryption.KekKeyId.ValueString()
		encryptionPayload.KekKeyRingId = model.Encryption.KekKeyRingId.ValueString()
		encryptionPayload.KekKeyVersion = model.Encryption.KekKeyVersion.ValueString()
		encryptionPayload.ServiceAccount = model.Encryption.ServiceAccount.ValueString()
	}

	networkPayload := v3beta1api.CreateInstanceRequestPayloadNetwork{}
	if !model.Network.IsNull() && !model.Network.IsUnknown() {
		accScope := v3beta1api.InstanceNetworkAccessScope(
			model.Network.AccessScope.ValueString(),
		)
		networkPayload.AccessScope = &accScope

		var resList []string
		diags := model.Network.Acl.ElementsAs(ctx, &resList, false)
		if diags.HasError() {
			return nil, fmt.Errorf("error converting network acl list")
		}
		networkPayload.Acl = resList
	}

	return &v3beta1api.CreateInstanceRequestPayload{
		BackupSchedule: model.BackupSchedule.ValueString(),
		Encryption:     encryptionPayload,
		FlavorId:       model.FlavorId.ValueString(),
		Name:           model.Name.ValueString(),
		Network:        networkPayload,
		RetentionDays:  int32(model.RetentionDays.ValueInt64()), //nolint:gosec // TODO
		Storage:        storagePayload,
		Version:        v3beta1api.InstanceVersion(model.Version.ValueString()),
	}, nil
}

func toUpdatePayload(
	ctx context.Context,
	m *sqlserverflexbetaResGen.InstanceModel,
	resp *resource.UpdateResponse,
) (*v3beta1api.UpdateInstanceRequestPayload, error) {
	if m == nil {
		return nil, fmt.Errorf("nil model")
	}
	if m.Replicas.ValueInt64() > math.MaxUint32 {
		return nil, fmt.Errorf("replicas value is too big for uint32")
	}
	replVal := v3beta1api.Replicas(uint32(m.Replicas.ValueInt64())) // nolint:gosec // check is performed above

	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")
	}
	if m.RetentionDays.ValueInt64() > math.MaxInt32 {
		return nil, fmt.Errorf("value is too large for int32")
	}
	return &v3beta1api.UpdateInstanceRequestPayload{
		BackupSchedule: m.BackupSchedule.ValueString(),
		FlavorId:       m.FlavorId.ValueString(),
		Name:           m.Name.ValueString(),
		Network: v3beta1api.UpdateInstanceRequestPayloadNetwork{
			Acl: netACL,
		},
		Replicas:      replVal,
		RetentionDays: int32(m.RetentionDays.ValueInt64()), //nolint:gosec // checked above
		Storage:       v3beta1api.StorageUpdate{Size: m.Storage.Size.ValueInt64Pointer()},
		Version:       v3beta1api.InstanceVersion(m.Version.ValueString()),
	}, nil
}