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

package postgresflexalpha

import (
	"context"
	"fmt"

	"github.com/hashicorp/terraform-plugin-framework/attr"
	"github.com/hashicorp/terraform-plugin-framework/types"
	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
	postgresflex "github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"

	postgresflexalphadatasource "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/instance/datasources_gen"
	postgresflexalpharesource "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/instance/resources_gen"
	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/utils"
)

func mapGetInstanceResponseToModel(
	ctx context.Context,
	m *postgresflexalpharesource.InstanceModel,
	resp *postgresflex.GetInstanceResponse,
) error {
	m.BackupSchedule = types.StringValue(resp.GetBackupSchedule())
	m.Encryption = postgresflexalpharesource.NewEncryptionValueNull()
	if resp.HasEncryption() {
		m.Encryption = postgresflexalpharesource.NewEncryptionValueMust(
			m.Encryption.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()),
			},
		)
	}

	isConnectionInfoIncomplete := resp.ConnectionInfo.Write.Host == "" || resp.ConnectionInfo.Write.Port == 0

	if isConnectionInfoIncomplete {
		m.ConnectionInfo = postgresflexalpharesource.NewConnectionInfoValueNull()
	} else {
		m.ConnectionInfo = postgresflexalpharesource.NewConnectionInfoValueMust(
			postgresflexalpharesource.ConnectionInfoValue{}.AttributeTypes(ctx),
			map[string]attr.Value{
				// careful - we can not use NewWriteValueMust here
				"write": basetypes.NewObjectValueMust(
					postgresflexalpharesource.WriteValue{}.AttributeTypes(ctx),
					map[string]attr.Value{
						"host": types.StringValue(resp.ConnectionInfo.Write.Host),
						// note: IDE does not show that port is actually an int64 in the Schema
						"port": types.Int64Value(int64(resp.ConnectionInfo.Write.Port)),
					},
				),
			},
		)
	}

	m.FlavorId = types.StringValue(resp.GetFlavorId())
	m.Id = utils.BuildInternalTerraformId(
		m.ProjectId.ValueString(),
		m.Region.ValueString(),
		resp.Id,
	)
	m.InstanceId = types.StringValue(resp.Id)

	m.IsDeletable = types.BoolValue(resp.GetIsDeletable())

	netACL, diags := types.ListValueFrom(ctx, types.StringType, resp.Network.GetAcl())
	if diags.HasError() {
		return fmt.Errorf("failed converting network acl from response")
	}

	m.Acl = netACL

	netInstAdd := types.StringValue("")
	if instAdd, ok := resp.Network.GetInstanceAddressOk(); ok {
		netInstAdd = types.StringValue(*instAdd)
	}

	netRtrAdd := types.StringValue("")
	if rtrAdd, ok := resp.Network.GetRouterAddressOk(); ok {
		netRtrAdd = types.StringValue(*rtrAdd)
	}

	net, diags := postgresflexalpharesource.NewNetworkValue(
		postgresflexalpharesource.NetworkValue{}.AttributeTypes(ctx),
		map[string]attr.Value{
			"access_scope":     basetypes.NewStringValue(string(resp.Network.GetAccessScope())),
			"acl":              netACL,
			"instance_address": netInstAdd,
			"router_address":   netRtrAdd,
		},
	)
	if diags.HasError() {
		return fmt.Errorf("failed converting network from response")
	}

	m.Network = net
	m.Replicas = types.Int64Value(int64(resp.GetReplicas()))
	m.RetentionDays = types.Int64Value(int64(resp.GetRetentionDays()))

	m.Name = types.StringValue(resp.GetName())

	m.Status = types.StringValue(string(resp.GetStatus()))

	storage, diags := postgresflexalpharesource.NewStorageValue(
		postgresflexalpharesource.StorageValue{}.AttributeTypes(ctx),
		map[string]attr.Value{
			"performance_class": types.StringValue(resp.Storage.GetPerformanceClass()),
			"size":              types.Int64Value(int64(resp.Storage.GetSize())),
		},
	)
	if diags.HasError() {
		return fmt.Errorf("failed converting storage from response")
	}
	m.Storage = storage

	m.Version = types.StringValue(resp.GetVersion())
	return nil
}

func mapGetDataInstanceResponseToModel(
	ctx context.Context,
	m *dataSourceModel,
	resp *postgresflex.GetInstanceResponse,
) error {
	m.BackupSchedule = types.StringValue(resp.GetBackupSchedule())
	handleEncryption(m, resp)
	handleConnectionInfo(ctx, m, resp)

	m.FlavorId = types.StringValue(resp.GetFlavorId())
	m.Id = types.StringValue(resp.Id)
	m.TerraformID = utils.BuildInternalTerraformId(m.ProjectId.ValueString(), m.Region.ValueString(), m.InstanceId.ValueString())
	m.InstanceId = types.StringValue(resp.Id)
	m.IsDeletable = types.BoolValue(resp.GetIsDeletable())
	m.Name = types.StringValue(resp.GetName())

	err := handleNetwork(ctx, m, resp)
	if err != nil {
		return err
	}

	m.Replicas = types.Int64Value(int64(resp.GetReplicas()))
	m.RetentionDays = types.Int64Value(int64(resp.GetRetentionDays()))
	m.Status = types.StringValue(string(resp.GetStatus()))
	storage, diags := postgresflexalphadatasource.NewStorageValue(
		postgresflexalphadatasource.StorageValue{}.AttributeTypes(ctx),
		map[string]attr.Value{
			"performance_class": types.StringValue(resp.Storage.GetPerformanceClass()),
			"size":              types.Int64Value(int64(resp.Storage.GetSize())),
		},
	)
	if diags.HasError() {
		return fmt.Errorf("failed converting storage from response")
	}
	m.Storage = storage
	m.Version = types.StringValue(resp.GetVersion())
	return nil
}

func handleConnectionInfo(ctx context.Context, m *dataSourceModel, resp *postgresflex.GetInstanceResponse) {
	isConnectionInfoIncomplete := resp.ConnectionInfo.Write.Host == "" || resp.ConnectionInfo.Write.Port == 0

	if isConnectionInfoIncomplete {
		m.ConnectionInfo = postgresflexalphadatasource.NewConnectionInfoValueNull()
	} else {
		m.ConnectionInfo = postgresflexalphadatasource.NewConnectionInfoValueMust(
			postgresflexalphadatasource.ConnectionInfoValue{}.AttributeTypes(ctx),
			map[string]attr.Value{
				"write": types.ObjectValueMust(
					postgresflexalphadatasource.WriteValue{}.AttributeTypes(ctx),
					map[string]attr.Value{
						"host": types.StringValue(resp.ConnectionInfo.Write.Host),
						"port": types.Int64Value(int64(resp.ConnectionInfo.Write.Port)),
					},
				),
			},
		)
	}
}

func handleNetwork(ctx context.Context, m *dataSourceModel, resp *postgresflex.GetInstanceResponse) error {
	netACL, diags := types.ListValueFrom(ctx, types.StringType, resp.Network.GetAcl())
	if diags.HasError() {
		return fmt.Errorf("failed converting network acl from response")
	}

	instAddr := ""
	if iA, ok := resp.Network.GetInstanceAddressOk(); ok {
		instAddr = *iA
	}

	rtrAddr := ""
	if rA, ok := resp.Network.GetRouterAddressOk(); ok {
		rtrAddr = *rA
	}

	net, diags := postgresflexalphadatasource.NewNetworkValue(
		postgresflexalphadatasource.NetworkValue{}.AttributeTypes(ctx),
		map[string]attr.Value{
			"access_scope":     types.StringValue(string(resp.Network.GetAccessScope())),
			"acl":              netACL,
			"instance_address": types.StringValue(instAddr),
			"router_address":   types.StringValue(rtrAddr),
		},
	)
	if diags.HasError() {
		return fmt.Errorf("failed converting network from response")
	}
	m.Network = net
	return nil
}

func handleEncryption(m *dataSourceModel, resp *postgresflex.GetInstanceResponse) {
	keyID := ""
	if keyIDVal, ok := resp.Encryption.GetKekKeyIdOk(); ok {
		keyID = *keyIDVal
	}

	keyRingID := ""
	if keyRingIDVal, ok := resp.Encryption.GetKekKeyRingIdOk(); ok {
		keyRingID = *keyRingIDVal
	}

	keyVersion := ""
	if keyVersionVal, ok := resp.Encryption.GetKekKeyVersionOk(); ok {
		keyVersion = *keyVersionVal
	}

	svcAcc := ""
	if svcAccVal, ok := resp.Encryption.GetServiceAccountOk(); ok {
		svcAcc = *svcAccVal
	}

	m.Encryption = postgresflexalphadatasource.EncryptionValue{
		KekKeyId:       types.StringValue(keyID),
		KekKeyRingId:   types.StringValue(keyRingID),
		KekKeyVersion:  types.StringValue(keyVersion),
		ServiceAccount: types.StringValue(svcAcc),
	}
}