feat: initial copy of v0.1.0

stackit/internal/conversion/conversion.go

@@ -11,7 +11,8 @@ import (
 	"github.com/hashicorp/terraform-plugin-framework/attr"
 	"github.com/hashicorp/terraform-plugin-framework/types"
 	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
+
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/core"
 )
 
 func ToString(ctx context.Context, v attr.Value) (string, error) {
@@ -89,6 +90,16 @@ func StringValueToPointer(s basetypes.StringValue) *string {
 	return &value
 }
 
+// Int32ValueToPointer converts basetypes.Int64Value to a pointer to int64.
+// It returns nil if the value is null or unknown.
+func Int32ValueToPointer(s basetypes.Int32Value) *int32 {
+	if s.IsNull() || s.IsUnknown() {
+		return nil
+	}
+	value := s.ValueInt32()
+	return &value
+}
+
 // Int64ValueToPointer converts basetypes.Int64Value to a pointer to int64.
 // It returns nil if the value is null or unknown.
 func Int64ValueToPointer(s basetypes.Int64Value) *int64 {

stackit/internal/conversion/conversion_test.go

@@ -8,7 +8,8 @@ import (
 	"testing"
 
 	"github.com/hashicorp/terraform-plugin-framework/diag"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
+
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/core"
 
 	"github.com/google/go-cmp/cmp"
 	"github.com/hashicorp/terraform-plugin-framework/attr"

stackit/internal/core/core.go

@@ -32,7 +32,7 @@ const (
 type EphemeralProviderData struct {
 	ProviderData
 
-	PrivateKey            string
+	PrivateKey            string //nolint:gosec //this is a placeholder and not used in this code
 	PrivateKeyPath        string
 	ServiceAccountKey     string
 	ServiceAccountKeyPath string
@@ -105,11 +105,13 @@ func DiagsToError(diags diag.Diagnostics) error {
 	diagsError := diags.Errors()
 	diagsStrings := make([]string, 0)
 	for _, diagnostic := range diagsError {
-		diagsStrings = append(diagsStrings, fmt.Sprintf(
-			"(%s) %s",
-			diagnostic.Summary(),
-			diagnostic.Detail(),
-		))
+		diagsStrings = append(
+			diagsStrings, fmt.Sprintf(
+				"(%s) %s",
+				diagnostic.Summary(),
+				diagnostic.Detail(),
+			),
+		)
 	}
 	return fmt.Errorf("%s", strings.Join(diagsStrings, ";"))
 }
@@ -136,14 +138,22 @@ func LogAndAddWarning(ctx context.Context, diags *diag.Diagnostics, summary, det
 
 func LogAndAddWarningBeta(ctx context.Context, diags *diag.Diagnostics, name string, resourceType ResourceType) {
 	warnTitle := fmt.Sprintf("The %s %q is in beta", resourceType, name)
-	warnContent := fmt.Sprintf("The %s %q is in beta and may be subject to breaking changes in the future. Use with caution.", resourceType, name)
+	warnContent := fmt.Sprintf(
+		"The %s %q is in beta and may be subject to breaking changes in the future. Use with caution.",
+		resourceType,
+		name,
+	)
 	tflog.Warn(ctx, fmt.Sprintf("%s | %s", warnTitle, warnContent))
 	diags.AddWarning(warnTitle, warnContent)
 }
 
 func LogAndAddErrorBeta(ctx context.Context, diags *diag.Diagnostics, name string, resourceType ResourceType) {
 	errTitle := fmt.Sprintf("The %s %q is in beta and beta is not enabled", resourceType, name)
-	errContent := fmt.Sprintf(`The %s %q is in beta and the beta functionality is currently not enabled. To enable it, set the environment variable STACKIT_TF_ENABLE_BETA_RESOURCES to "true" or set the "enable_beta_resources" provider field to true.`, resourceType, name)
+	errContent := fmt.Sprintf(
+		`The %s %q is in beta and the beta functionality is currently not enabled. To enable it, set the environment variable STACKIT_TF_ENABLE_BETA_RESOURCES to "true" or set the "enable_beta_resources" provider field to true.`,
+		resourceType,
+		name,
+	)
 	tflog.Error(ctx, fmt.Sprintf("%s | %s", errTitle, errContent))
 	diags.AddError(errTitle, errContent)
 }
@@ -161,8 +171,10 @@ func LogResponse(ctx context.Context) context.Context {
 	traceId := runtime.GetTraceId(ctx)
 	ctx = tflog.SetField(ctx, "x-trace-id", traceId)
 
-	tflog.Info(ctx, "response data", map[string]interface{}{
-		"x-trace-id": traceId,
-	})
+	tflog.Info(
+		ctx, "response data", map[string]interface{}{
+			"x-trace-id": traceId,
+		},
+	)
 	return ctx
 }

stackit/internal/core/retry_round_tripper.go

@@ -0,0 +1,237 @@
+package core
+
+import (
+	"context"
+	"crypto/rand"
+	"errors"
+	"fmt"
+	"math/big"
+	"net/http"
+	"time"
+
+	"github.com/hashicorp/terraform-plugin-log/tflog"
+)
+
+const (
+	// backoffMultiplier is the factor by which the delay is multiplied for exponential backoff.
+	backoffMultiplier = 2
+	// jitterFactor is the divisor used to calculate jitter (e.g., half of the base delay).
+	jitterFactor = 2
+)
+
+var (
+	// ErrRequestFailedAfterRetries is returned when a request fails after all retry attempts.
+	ErrRequestFailedAfterRetries = errors.New("request failed after all retry attempts")
+)
+
+// RetryRoundTripper implements an http.RoundTripper that adds automatic retry logic for failed requests.
+type RetryRoundTripper struct {
+	next          http.RoundTripper
+	maxRetries    int
+	initialDelay  time.Duration
+	maxDelay      time.Duration
+	perTryTimeout time.Duration
+}
+
+// NewRetryRoundTripper creates a new instance of the RetryRoundTripper with the specified configuration.
+func NewRetryRoundTripper(
+	next http.RoundTripper,
+	maxRetries int,
+	initialDelay, maxDelay, perTryTimeout time.Duration,
+) *RetryRoundTripper {
+	return &RetryRoundTripper{
+		next:          next,
+		maxRetries:    maxRetries,
+		initialDelay:  initialDelay,
+		maxDelay:      maxDelay,
+		perTryTimeout: perTryTimeout,
+	}
+}
+
+// RoundTrip executes the request and retries on failure.
+func (rrt *RetryRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+	resp, err := rrt.executeRequest(req)
+	if !rrt.shouldRetry(resp, err) {
+		if err != nil {
+			return resp, fmt.Errorf("initial request failed, not retrying: %w", err)
+		}
+
+		return resp, nil
+	}
+
+	return rrt.retryLoop(req, resp, err)
+}
+
+// executeRequest performs a single HTTP request with a per-try timeout.
+func (rrt *RetryRoundTripper) executeRequest(req *http.Request) (*http.Response, error) {
+	ctx, cancel := context.WithTimeout(req.Context(), rrt.perTryTimeout)
+	defer cancel()
+
+	resp, err := rrt.next.RoundTrip(req.WithContext(ctx))
+	if err != nil {
+		if errors.Is(err, context.DeadlineExceeded) {
+			return resp, fmt.Errorf("per-try timeout of %v exceeded: %w", rrt.perTryTimeout, err)
+		}
+
+		return resp, fmt.Errorf("http roundtrip failed: %w", err)
+	}
+
+	return resp, nil
+}
+
+// retryLoop handles the retry logic for a failed request.
+func (rrt *RetryRoundTripper) retryLoop(
+	req *http.Request,
+	initialResp *http.Response,
+	initialErr error,
+) (*http.Response, error) {
+	var (
+		lastErr      = initialErr
+		resp         = initialResp
+		currentDelay = rrt.initialDelay
+	)
+
+	ctx := req.Context()
+
+	for attempt := 1; attempt <= rrt.maxRetries; attempt++ {
+		rrt.logRetryAttempt(ctx, attempt, currentDelay, lastErr)
+
+		waitDuration := rrt.calculateWaitDurationWithJitter(ctx, currentDelay)
+		if err := rrt.waitForDelay(ctx, waitDuration); err != nil {
+			return nil, err // Context was canceled during wait.
+		}
+
+		// Exponential backoff for the next potential retry.
+		currentDelay = rrt.updateCurrentDelay(currentDelay)
+
+		// Retry attempt.
+		resp, lastErr = rrt.executeRequest(req)
+		if !rrt.shouldRetry(resp, lastErr) {
+			if lastErr != nil {
+				return resp, fmt.Errorf("request failed on retry attempt %d: %w", attempt, lastErr)
+			}
+
+			return resp, nil
+		}
+	}
+
+	return nil, rrt.handleFinalError(ctx, resp, lastErr)
+}
+
+// logRetryAttempt logs the details of a retry attempt.
+func (rrt *RetryRoundTripper) logRetryAttempt(
+	ctx context.Context,
+	attempt int,
+	delay time.Duration,
+	err error,
+) {
+	tflog.Info(
+		ctx, "Request failed, retrying...", map[string]interface{}{
+			"attempt":      attempt,
+			"max_attempts": rrt.maxRetries,
+			"delay":        delay,
+			"error":        err,
+		},
+	)
+}
+
+// updateCurrentDelay calculates the next delay for exponential backoff.
+func (rrt *RetryRoundTripper) updateCurrentDelay(currentDelay time.Duration) time.Duration {
+	currentDelay *= backoffMultiplier
+	if currentDelay > rrt.maxDelay {
+		return rrt.maxDelay
+	}
+
+	return currentDelay
+}
+
+// handleFinalError constructs and returns the final error after all retries have been exhausted.
+func (rrt *RetryRoundTripper) handleFinalError(
+	ctx context.Context,
+	resp *http.Response,
+	lastErr error,
+) error {
+	if resp != nil {
+		if err := resp.Body.Close(); err != nil {
+			tflog.Warn(
+				ctx, "Failed to close response body", map[string]interface{}{
+					"error": err.Error(),
+				},
+			)
+		}
+	}
+
+	if lastErr != nil {
+		return fmt.Errorf("%w: %w", ErrRequestFailedAfterRetries, lastErr)
+	}
+
+	// This case occurs if shouldRetry was true due to a retryable status code,
+	// but all retries failed with similar status codes.
+	if resp != nil {
+		return fmt.Errorf(
+			"%w: last retry attempt failed with status code %d",
+			ErrRequestFailedAfterRetries,
+			resp.StatusCode,
+		)
+	}
+
+	return fmt.Errorf("%w: no response received", ErrRequestFailedAfterRetries)
+}
+
+// shouldRetry determines if a request should be retried based on the response or an error.
+func (rrt *RetryRoundTripper) shouldRetry(resp *http.Response, err error) bool {
+	if err != nil {
+		return true
+	}
+
+	if resp != nil {
+		if resp.StatusCode == http.StatusBadGateway ||
+			resp.StatusCode == http.StatusServiceUnavailable ||
+			resp.StatusCode == http.StatusGatewayTimeout {
+			return true
+		}
+	}
+
+	return false
+}
+
+// calculateWaitDurationWithJitter calculates the backoff duration for the next retry,
+// adding a random jitter to prevent thundering herd issues.
+func (rrt *RetryRoundTripper) calculateWaitDurationWithJitter(
+	ctx context.Context,
+	baseDelay time.Duration,
+) time.Duration {
+	if baseDelay <= 0 {
+		return 0
+	}
+
+	maxJitter := int64(baseDelay / jitterFactor)
+	if maxJitter <= 0 {
+		return baseDelay
+	}
+
+	random, err := rand.Int(rand.Reader, big.NewInt(maxJitter))
+	if err != nil {
+		tflog.Warn(
+			ctx, "Failed to generate random jitter, proceeding without it.", map[string]interface{}{
+				"error": err.Error(),
+			},
+		)
+
+		return baseDelay
+	}
+
+	jitter := time.Duration(random.Int64())
+
+	return baseDelay + jitter
+}
+
+// waitForDelay pauses execution for a given duration or until the context is canceled.
+func (rrt *RetryRoundTripper) waitForDelay(ctx context.Context, delay time.Duration) error {
+	select {
+	case <-ctx.Done():
+		return fmt.Errorf("context canceled during backoff wait: %w", ctx.Err())
+	case <-time.After(delay):
+		return nil
+	}
+}

stackit/internal/core/retry_round_tripper_test.go

@@ -0,0 +1,252 @@
+package core
+
+import (
+	"context"
+	"errors"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+type mockRoundTripper struct {
+	roundTripFunc func(req *http.Request) (*http.Response, error)
+	callCount     int32
+}
+
+func (m *mockRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+	atomic.AddInt32(&m.callCount, 1)
+
+	return m.roundTripFunc(req)
+}
+
+func (m *mockRoundTripper) CallCount() int32 {
+	return atomic.LoadInt32(&m.callCount)
+}
+
+func TestRetryRoundTripper_RoundTrip(t *testing.T) {
+	t.Parallel()
+
+	testRetryConfig := func(next http.RoundTripper) *RetryRoundTripper {
+		return NewRetryRoundTripper(
+			next,
+			3,
+			1*time.Millisecond,
+			10*time.Millisecond,
+			50*time.Millisecond,
+		)
+	}
+
+	noRetryTests := []struct {
+		name               string
+		mockStatusCode     int
+		expectedStatusCode int
+	}{
+		{
+			name:               "should succeed on the first try",
+			mockStatusCode:     http.StatusOK,
+			expectedStatusCode: http.StatusOK,
+		},
+		{
+			name:               "should not retry on a non-retryable status code like 400",
+			mockStatusCode:     http.StatusBadRequest,
+			expectedStatusCode: http.StatusBadRequest,
+		},
+	}
+
+	for _, testCase := range noRetryTests {
+		t.Run(
+			testCase.name, func(t *testing.T) {
+				t.Parallel()
+
+				mock := &mockRoundTripper{
+					roundTripFunc: func(req *http.Request) (*http.Response, error) {
+						return &http.Response{
+							StatusCode: testCase.mockStatusCode,
+							Body:       io.NopCloser(nil),
+							Request:    req,
+						}, nil
+					},
+				}
+				tripper := testRetryConfig(mock)
+				req := httptest.NewRequest(http.MethodGet, "/", http.NoBody)
+
+				resp, err := tripper.RoundTrip(req)
+				if resp != nil {
+					defer func() {
+						if closeErr := resp.Body.Close(); closeErr != nil {
+							t.Errorf("failed to close response body: %v", closeErr)
+						}
+					}()
+				}
+
+				if err != nil {
+					t.Fatalf("expected no error, got %v", err)
+				}
+				if resp.StatusCode != testCase.expectedStatusCode {
+					t.Fatalf("expected status code %d, got %d", testCase.expectedStatusCode, resp.StatusCode)
+				}
+				if mock.CallCount() != 1 {
+					t.Fatalf("expected 1 call, got %d", mock.CallCount())
+				}
+			},
+		)
+	}
+
+	t.Run(
+		"should retry on retryable status code (503) and eventually fail", func(t *testing.T) {
+			t.Parallel()
+
+			mock := &mockRoundTripper{
+				roundTripFunc: func(req *http.Request) (*http.Response, error) {
+					return &http.Response{
+						StatusCode: http.StatusServiceUnavailable,
+						Body:       io.NopCloser(nil),
+						Request:    req,
+					}, nil
+				},
+			}
+			tripper := testRetryConfig(mock)
+			req := httptest.NewRequest(http.MethodGet, "/", http.NoBody)
+
+			resp, err := tripper.RoundTrip(req)
+			if resp != nil {
+				defer func() {
+					if closeErr := resp.Body.Close(); closeErr != nil {
+						t.Errorf("failed to close response body: %v", closeErr)
+					}
+				}()
+			}
+
+			if err == nil {
+				t.Fatal("expected an error, but got nil")
+			}
+			expectedErrorMsg := "last retry attempt failed with status code 503"
+			if !strings.Contains(err.Error(), expectedErrorMsg) {
+				t.Fatalf("expected error to contain %q, got %q", expectedErrorMsg, err.Error())
+			}
+			if mock.CallCount() != 4 { // 1 initial + 3 retries
+				t.Fatalf("expected 4 calls, got %d", mock.CallCount())
+			}
+		},
+	)
+
+	t.Run(
+		"should succeed after one retry", func(t *testing.T) {
+			t.Parallel()
+
+			mock := &mockRoundTripper{}
+			mock.roundTripFunc = func(req *http.Request) (*http.Response, error) {
+				if mock.CallCount() < 2 {
+					return &http.Response{
+						StatusCode: http.StatusServiceUnavailable,
+						Body:       io.NopCloser(nil),
+						Request:    req,
+					}, nil
+				}
+
+				return &http.Response{
+					StatusCode: http.StatusOK,
+					Body:       io.NopCloser(nil),
+					Request:    req,
+				}, nil
+			}
+			tripper := testRetryConfig(mock)
+			req := httptest.NewRequest(http.MethodGet, "/", http.NoBody)
+
+			resp, err := tripper.RoundTrip(req)
+			if resp != nil {
+				defer func() {
+					if closeErr := resp.Body.Close(); closeErr != nil {
+						t.Errorf("failed to close response body: %v", closeErr)
+					}
+				}()
+			}
+
+			if err != nil {
+				t.Fatalf("expected no error, got %v", err)
+			}
+			if resp.StatusCode != http.StatusOK {
+				t.Fatalf("expected status code %d, got %d", http.StatusOK, resp.StatusCode)
+			}
+			if mock.CallCount() != 2 {
+				t.Fatalf("expected 2 calls, got %d", mock.CallCount())
+			}
+		},
+	)
+
+	t.Run(
+		"should retry on network error", func(t *testing.T) {
+			t.Parallel()
+
+			mockErr := errors.New("simulated network error")
+
+			mock := &mockRoundTripper{
+				roundTripFunc: func(_ *http.Request) (*http.Response, error) {
+					return nil, mockErr
+				},
+			}
+			tripper := testRetryConfig(mock)
+			req := httptest.NewRequest(http.MethodGet, "/", http.NoBody)
+
+			resp, err := tripper.RoundTrip(req)
+			if resp != nil {
+				defer func() {
+					if closeErr := resp.Body.Close(); closeErr != nil {
+						t.Errorf("failed to close response body: %v", closeErr)
+					}
+				}()
+			}
+
+			if !errors.Is(err, mockErr) {
+				t.Fatalf("expected error to be %v, got %v", mockErr, err)
+			}
+			if mock.CallCount() != 4 { // 1 initial + 3 retries
+				t.Fatalf("expected 4 calls, got %d", mock.CallCount())
+			}
+		},
+	)
+
+	t.Run(
+		"should abort retries if the main context is canceled", func(t *testing.T) {
+			t.Parallel()
+
+			mock := &mockRoundTripper{
+				roundTripFunc: func(req *http.Request) (*http.Response, error) {
+					select {
+					case <-time.After(100 * time.Millisecond):
+						return nil, errors.New("this should not be returned")
+					case <-req.Context().Done():
+						return nil, req.Context().Err()
+					}
+				},
+			}
+			tripper := testRetryConfig(mock)
+			baseCtx := context.Background()
+
+			ctx, cancel := context.WithTimeout(baseCtx, 20*time.Millisecond)
+			defer cancel()
+
+			req := httptest.NewRequest(http.MethodGet, "/", http.NoBody).WithContext(ctx)
+
+			resp, err := tripper.RoundTrip(req)
+			if resp != nil {
+				defer func() {
+					if closeErr := resp.Body.Close(); closeErr != nil {
+						t.Errorf("failed to close response body: %v", closeErr)
+					}
+				}()
+			}
+
+			if !errors.Is(err, context.DeadlineExceeded) {
+				t.Fatalf("expected error to be context.DeadlineExceeded, got %v", err)
+			}
+			if mock.CallCount() != 1 {
+				t.Fatalf("expected 1 call, got %d", mock.CallCount())
+			}
+		},
+	)
+}

stackit/internal/features/beta.go

@@ -9,7 +9,8 @@ import (
 	"strings"
 
 	"github.com/hashicorp/terraform-plugin-framework/diag"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
+
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/core"
 )
 
 // BetaResourcesEnabled returns whether this provider has beta functionality enabled.

stackit/internal/features/beta_test.go

@@ -7,7 +7,8 @@ import (
 	"testing"
 
 	"github.com/hashicorp/terraform-plugin-framework/diag"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
+
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/core"
 )
 
 func TestBetaResourcesEnabled(t *testing.T) {

stackit/internal/features/experiments.go

@@ -10,7 +10,8 @@ import (
 
 	"github.com/hashicorp/terraform-plugin-framework/diag"
 	"github.com/hashicorp/terraform-plugin-log/tflog"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
+
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/core"
 )
 
 const (

stackit/internal/features/experiments_test.go

@@ -7,7 +7,8 @@ import (
 	"testing"
 
 	"github.com/hashicorp/terraform-plugin-framework/diag"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
+
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/core"
 )
 
 func TestValidExperiment(t *testing.T) {

stackit/internal/services/postgresflexalpha/database/datasource.go

@@ -0,0 +1,196 @@
+package postgresflexalpha
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource"
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+	"github.com/hashicorp/terraform-plugin-framework/diag"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/hashicorp/terraform-plugin-log/tflog"
+
+	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
+
+	"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"
+	pgDsGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/database/datasources_gen"
+	postgresflexUtils "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/utils"
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/utils"
+)
+
+// Ensure the implementation satisfies the expected interfaces.
+var (
+	_ datasource.DataSource = &databaseDataSource{}
+)
+
+// NewDatabaseDataSource is a helper function to simplify the provider implementation.
+func NewDatabaseDataSource() datasource.DataSource {
+	return &databaseDataSource{}
+}
+
+// dataSourceModel maps the data source schema data.
+type dataSourceModel struct {
+	pgDsGen.DatabaseModel
+	TerraformID types.String `tfsdk:"id"`
+}
+
+// databaseDataSource is the data source implementation.
+type databaseDataSource struct {
+	client       *v3alpha1api.APIClient
+	providerData core.ProviderData
+}
+
+// Metadata returns the data source type name.
+func (r *databaseDataSource) Metadata(
+	_ context.Context,
+	req datasource.MetadataRequest,
+	resp *datasource.MetadataResponse,
+) {
+	resp.TypeName = req.ProviderTypeName + "_postgresflexalpha_database"
+}
+
+// Configure adds the provider configured client to the data source.
+func (r *databaseDataSource) Configure(
+	ctx context.Context,
+	req datasource.ConfigureRequest,
+	resp *datasource.ConfigureResponse,
+) {
+	var ok bool
+	r.providerData, ok = conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
+	if !ok {
+		return
+	}
+
+	apiClient := postgresflexUtils.ConfigureClient(ctx, &r.providerData, &resp.Diagnostics)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	r.client = apiClient
+	tflog.Info(ctx, "Postgres Flex database client configured")
+}
+
+// Schema defines the schema for the data source.
+func (r *databaseDataSource) Schema(ctx context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	s := pgDsGen.DatabaseDataSourceSchema(ctx)
+	s.Attributes["id"] = schema.StringAttribute{
+		Description: "Terraform's internal resource ID. It is structured as \\\"`project_id`,`region`,`instance_id`," +
+			"`database_id`\\\".\",",
+		Computed: true,
+	}
+
+	resp.Schema = s
+}
+
+// Read fetches the data for the data source.
+func (r *databaseDataSource) Read(
+	ctx context.Context,
+	req datasource.ReadRequest,
+	resp *datasource.ReadResponse,
+) { // nolint:gocritic // function signature required by Terraform
+	var model dataSourceModel
+	diags := req.Config.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 := r.providerData.GetRegionWithOverride(model.Region)
+	ctx = tflog.SetField(ctx, "project_id", projectId)
+	ctx = tflog.SetField(ctx, "instance_id", instanceId)
+	ctx = tflog.SetField(ctx, "region", region)
+
+	databaseResp, err := r.getDatabaseByNameOrID(ctx, &model, projectId, region, instanceId, &resp.Diagnostics)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	if err != nil {
+		handleReadError(ctx, &resp.Diagnostics, err, projectId, instanceId)
+		resp.State.RemoveResource(ctx)
+		return
+	}
+
+	ctx = core.LogResponse(ctx)
+
+	// Map response body to schema and populate Computed attribute values
+	err = mapFields(databaseResp, &model, region)
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"Error reading database",
+			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, "Postgres Flex database read")
+}
+
+// getDatabaseByNameOrID retrieves a single database by ensuring either a unique ID or name is provided.
+func (r *databaseDataSource) getDatabaseByNameOrID(
+	ctx context.Context,
+	model *dataSourceModel,
+	projectId, region, instanceId string,
+	diags *diag.Diagnostics,
+) (*v3alpha1api.ListDatabase, error) {
+	isIdSet := !model.DatabaseId.IsNull() && !model.DatabaseId.IsUnknown()
+	isNameSet := !model.Name.IsNull() && !model.Name.IsUnknown()
+
+	if (isIdSet && isNameSet) || (!isIdSet && !isNameSet) {
+		diags.AddError(
+			"Invalid configuration",
+			"Exactly one of 'id' or 'name' must be specified.",
+		)
+		return nil, nil
+	}
+
+	if isIdSet {
+		databaseId := model.DatabaseId.ValueInt64()
+		ctx = tflog.SetField(ctx, "database_id", databaseId)
+		return getDatabaseById(ctx, r.client.DefaultAPI, projectId, region, instanceId, databaseId)
+	}
+
+	databaseName := model.Name.ValueString()
+	ctx = tflog.SetField(ctx, "name", databaseName)
+	return getDatabaseByName(ctx, r.client.DefaultAPI, projectId, region, instanceId, databaseName)
+}
+
+// handleReadError centralizes API error handling for the Read operation.
+func handleReadError(ctx context.Context, diags *diag.Diagnostics, err error, projectId, instanceId string) {
+	utils.LogError(
+		ctx,
+		diags,
+		err,
+		"Reading database",
+		fmt.Sprintf(
+			"Could not retrieve database for instance %q in project %q.",
+			instanceId,
+			projectId,
+		),
+		map[int]string{
+			http.StatusBadRequest: fmt.Sprintf(
+				"Invalid request parameters for project %q and instance %q.",
+				projectId,
+				instanceId,
+			),
+			http.StatusNotFound: fmt.Sprintf(
+				"Database, instance %q, or project %q not found.",
+				instanceId,
+				projectId,
+			),
+			http.StatusForbidden: fmt.Sprintf("Forbidden access to project %q.", projectId),
+		},
+	)
+}

stackit/internal/services/postgresflexalpha/database/datasource.go.bak

@@ -1,171 +0,0 @@
-package postgresflexa
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/conversion"
-	postgresflexUtils "github.com/stackitcloud/terraform-provider-stackit/stackit/internal/services/postgresflexalpha/utils"
-
-	"github.com/hashicorp/terraform-plugin-framework/datasource"
-	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
-	"github.com/hashicorp/terraform-plugin-log/tflog"
-	"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/datasource/schema"
-	"github.com/stackitcloud/terraform-provider-stackit/pkg/postgresflexalpha"
-)
-
-// Ensure the implementation satisfies the expected interfaces.
-var (
-	_ datasource.DataSource = &databaseDataSource{}
-)
-
-// NewDatabaseDataSource is a helper function to simplify the provider implementation.
-func NewDatabaseDataSource() datasource.DataSource {
-	return &databaseDataSource{}
-}
-
-// databaseDataSource is the data source implementation.
-type databaseDataSource struct {
-	client       *postgresflexalpha.APIClient
-	providerData core.ProviderData
-}
-
-// Metadata returns the data source type name.
-func (r *databaseDataSource) Metadata(_ context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {
-	resp.TypeName = req.ProviderTypeName + "_postgresflexalpha_database"
-}
-
-// Configure adds the provider configured client to the data source.
-func (r *databaseDataSource) Configure(ctx context.Context, req datasource.ConfigureRequest, resp *datasource.ConfigureResponse) {
-	var ok bool
-	r.providerData, ok = conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
-	if !ok {
-		return
-	}
-
-	apiClient := postgresflexUtils.ConfigureClient(ctx, &r.providerData, &resp.Diagnostics)
-	if resp.Diagnostics.HasError() {
-		return
-	}
-	r.client = apiClient
-	tflog.Info(ctx, "Postgres Flex database client configured")
-}
-
-// Schema defines the schema for the data source.
-func (r *databaseDataSource) Schema(_ context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
-	descriptions := map[string]string{
-		"main":        "Postgres Flex database 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`,`database_id`\".",
-		"database_id": "Database ID.",
-		"instance_id": "ID of the Postgres Flex instance.",
-		"project_id":  "STACKIT project ID to which the instance is associated.",
-		"name":        "Database name.",
-		"owner":       "Username of the database owner.",
-		"region":      "The resource region. If not defined, the provider region is used.",
-	}
-
-	resp.Schema = schema.Schema{
-		Description: descriptions["main"],
-		Attributes: map[string]schema.Attribute{
-			"id": schema.StringAttribute{
-				Description: descriptions["id"],
-				Computed:    true,
-			},
-			"database_id": schema.StringAttribute{
-				Description: descriptions["database_id"],
-				Required:    true,
-				Validators: []validator.String{
-					validate.NoSeparator(),
-				},
-			},
-			"instance_id": schema.StringAttribute{
-				Description: descriptions["instance_id"],
-				Required:    true,
-				Validators: []validator.String{
-					validate.UUID(),
-					validate.NoSeparator(),
-				},
-			},
-			"project_id": schema.StringAttribute{
-				Description: descriptions["project_id"],
-				Required:    true,
-				Validators: []validator.String{
-					validate.UUID(),
-					validate.NoSeparator(),
-				},
-			},
-			"name": schema.StringAttribute{
-				Description: descriptions["name"],
-				Computed:    true,
-			},
-			"owner": schema.StringAttribute{
-				Description: descriptions["owner"],
-				Computed:    true,
-			},
-			"region": schema.StringAttribute{
-				// the region cannot be found, so it has to be passed
-				Optional:    true,
-				Description: descriptions["region"],
-			},
-		},
-	}
-}
-
-// Read refreshes the Terraform state with the latest data.
-func (r *databaseDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) { // nolint:gocritic // function signature required by Terraform
-	var model Model
-	diags := req.Config.Get(ctx, &model)
-	resp.Diagnostics.Append(diags...)
-	if resp.Diagnostics.HasError() {
-		return
-	}
-
-	ctx = core.InitProviderContext(ctx)
-
-	projectId := model.ProjectId.ValueString()
-	instanceId := model.InstanceId.ValueString()
-	databaseId := model.DatabaseId.ValueString()
-	region := r.providerData.GetRegionWithOverride(model.Region)
-	ctx = tflog.SetField(ctx, "project_id", projectId)
-	ctx = tflog.SetField(ctx, "instance_id", instanceId)
-	ctx = tflog.SetField(ctx, "database_id", databaseId)
-	ctx = tflog.SetField(ctx, "region", region)
-
-	databaseResp, err := getDatabase(ctx, r.client, projectId, region, instanceId, databaseId)
-	if err != nil {
-		utils.LogError(
-			ctx,
-			&resp.Diagnostics,
-			err,
-			"Reading database",
-			fmt.Sprintf("Database with ID %q or instance with ID %q does not exist in project %q.", databaseId, instanceId, projectId),
-			map[int]string{
-				http.StatusForbidden: fmt.Sprintf("Project with ID %q not found or forbidden access", projectId),
-			},
-		)
-		resp.State.RemoveResource(ctx)
-		return
-	}
-
-	ctx = core.LogResponse(ctx)
-
-	// Map response body to schema and populate Computed attribute values
-	err = mapFields(databaseResp, &model, region)
-	if err != nil {
-		core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading database", 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, "Postgres Flex database read")
-}

stackit/internal/services/postgresflexalpha/database/datasources_gen/database_data_source_gen.go

@@ -0,0 +1,69 @@
+// Code generated by terraform-plugin-framework-generator DO NOT EDIT.
+
+package postgresflexalpha
+
+import (
+	"context"
+	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
+	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+)
+
+func DatabaseDataSourceSchema(ctx context.Context) schema.Schema {
+	return schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"database_id": schema.Int64Attribute{
+				Required:            true,
+				Description:         "The ID of the database.",
+				MarkdownDescription: "The ID of the database.",
+			},
+			"tf_original_api_id": schema.Int64Attribute{
+				Computed:            true,
+				Description:         "The id of the database.",
+				MarkdownDescription: "The id of the database.",
+			},
+			"instance_id": schema.StringAttribute{
+				Required:            true,
+				Description:         "The ID of the instance.",
+				MarkdownDescription: "The ID of the instance.",
+			},
+			"name": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The name of the database.",
+				MarkdownDescription: "The name of the database.",
+			},
+			"owner": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The owner of the database.",
+				MarkdownDescription: "The owner of the database.",
+			},
+			"project_id": schema.StringAttribute{
+				Required:            true,
+				Description:         "The STACKIT project ID.",
+				MarkdownDescription: "The STACKIT project ID.",
+			},
+			"region": schema.StringAttribute{
+				Required:            true,
+				Description:         "The region which should be addressed",
+				MarkdownDescription: "The region which should be addressed",
+				Validators: []validator.String{
+					stringvalidator.OneOf(
+						"eu01",
+					),
+				},
+			},
+		},
+	}
+}
+
+type DatabaseModel struct {
+	DatabaseId types.Int64  `tfsdk:"database_id"`
+	Id         types.Int64  `tfsdk:"tf_original_api_id"`
+	InstanceId types.String `tfsdk:"instance_id"`
+	Name       types.String `tfsdk:"name"`
+	Owner      types.String `tfsdk:"owner"`
+	ProjectId  types.String `tfsdk:"project_id"`
+	Region     types.String `tfsdk:"region"`
+}

stackit/internal/services/postgresflexalpha/database/functions.go

@@ -0,0 +1,87 @@
+package postgresflexalpha
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
+)
+
+// databaseClientReader represents the contract to listing databases from postgresflex.APIClient.
+type databaseClientReader interface {
+	ListDatabasesRequest(
+		ctx context.Context,
+		projectId string,
+		region string,
+		instanceId string,
+	) v3alpha1api.ApiListDatabasesRequestRequest
+}
+
+// getDatabaseById gets a database by its ID.
+func getDatabaseById(
+	ctx context.Context,
+	client databaseClientReader,
+	projectId, region, instanceId string,
+	databaseId int64,
+) (*v3alpha1api.ListDatabase, error) {
+	filter := func(db v3alpha1api.ListDatabase) bool {
+		return int64(db.Id) == databaseId
+	}
+	return getDatabase(ctx, client, projectId, region, instanceId, filter)
+}
+
+// getDatabaseByName gets a database by its name.
+func getDatabaseByName(
+	ctx context.Context,
+	client databaseClientReader,
+	projectId, region, instanceId, databaseName string,
+) (*v3alpha1api.ListDatabase, error) {
+	filter := func(db v3alpha1api.ListDatabase) bool {
+		return db.Name == databaseName
+	}
+	return getDatabase(ctx, client, projectId, region, instanceId, filter)
+}
+
+// getDatabase is a helper function to retrieve a database using a filter function.
+// Hint: The API does not have a GetDatabase endpoint, only ListDatabases
+func getDatabase(
+	ctx context.Context,
+	client databaseClientReader,
+	projectId, region, instanceId string,
+	filter func(db v3alpha1api.ListDatabase) bool,
+) (*v3alpha1api.ListDatabase, error) {
+	if projectId == "" || region == "" || instanceId == "" {
+		return nil, fmt.Errorf("all parameters (project, region, instance) are required")
+	}
+
+	const pageSize = 25
+
+	for page := int32(1); ; page++ {
+		res, err := client.ListDatabasesRequest(ctx, projectId, region, instanceId).
+			Page(page).Size(pageSize).Sort(v3alpha1api.DATABASESORT_DATABASE_ID_ASC).Execute()
+		if err != nil {
+			return nil, fmt.Errorf("requesting database list (page %d): %w", page, err)
+		}
+
+		// If the API returns no databases, we have reached the end of the list.
+		if len(res.Databases) == 0 {
+			break
+		}
+
+		// Iterate over databases to find a match
+		for _, db := range res.Databases {
+			if filter(db) {
+				foundDb := db
+				return &foundDb, nil
+			}
+		}
+	}
+
+	return nil, fmt.Errorf("database not found for instance %s", instanceId)
+}
+
+// cleanString removes leading and trailing quotes which are sometimes returned by the API.
+func cleanString(s string) string {
+	return strings.Trim(s, "\"")
+}

stackit/internal/services/postgresflexalpha/database/functions_test.go

@@ -0,0 +1,199 @@
+package postgresflexalpha
+
+import (
+	"context"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
+)
+
+func TestGetDatabase(t *testing.T) {
+	mockResp := func(page int32) (*v3alpha1api.ListDatabasesResponse, error) {
+		if page == 1 {
+			return &v3alpha1api.ListDatabasesResponse{
+				Databases: []v3alpha1api.ListDatabase{
+					{Id: int32(1), Name: "first"},
+					{Id: int32(2), Name: "second"},
+				},
+				Pagination: v3alpha1api.Pagination{
+					Page:       int32(1),
+					TotalPages: int32(2),
+					Size:       int32(3),
+				},
+			}, nil
+		}
+
+		if page == 2 {
+			return &v3alpha1api.ListDatabasesResponse{
+				Databases: []v3alpha1api.ListDatabase{{Id: int32(3), Name: "three"}},
+				Pagination: v3alpha1api.Pagination{
+					Page:       int32(2),
+					TotalPages: int32(2),
+					Size:       int32(3),
+				},
+			}, nil
+		}
+
+		return &v3alpha1api.ListDatabasesResponse{
+			Databases: []v3alpha1api.ListDatabase{},
+			Pagination: v3alpha1api.Pagination{
+				Page:       int32(3),
+				TotalPages: int32(2),
+				Size:       int32(3),
+			},
+		}, nil
+	}
+
+	tests := []struct {
+		description string
+		projectID   string
+		region      string
+		instanceID  string
+		wantErr     bool
+		wantDbName  string
+		wantDbID    int32
+	}{
+		{
+			description: "Success - Found by name on first page",
+			projectID:   "pid", region: "reg", instanceID: "inst",
+			wantErr:    false,
+			wantDbName: "second",
+		},
+		{
+			description: "Success - Found by id on first page",
+			projectID:   "pid", region: "reg", instanceID: "inst",
+			wantErr:  false,
+			wantDbID: 2,
+		},
+		{
+			description: "Success - Found by name on second page",
+			projectID:   "pid", region: "reg", instanceID: "inst",
+			wantErr:    false,
+			wantDbName: "three",
+		},
+		{
+			description: "Success - Found by id on second page",
+			projectID:   "pid", region: "reg", instanceID: "inst",
+			wantErr:  false,
+			wantDbID: 1,
+		},
+		{
+			description: "Error - API failure",
+			projectID:   "pid", region: "reg", instanceID: "inst",
+			wantErr: true,
+		},
+		{
+			description: "Error - Missing parameters",
+			projectID:   "", region: "reg", instanceID: "inst",
+			wantErr: true,
+		},
+		{
+			description: "Error - Search by name not found after all pages",
+			projectID:   "pid", region: "reg", instanceID: "inst",
+			wantDbName: "non-existent",
+			wantErr:    true,
+		},
+		{
+			description: "Error - Search by id not found after all pages",
+			projectID:   "pid", region: "reg", instanceID: "inst",
+			wantDbID: 999999,
+			wantErr:  true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(
+			tt.description, func(t *testing.T) {
+				var currentPage int32
+
+				mockCall := func(_ v3alpha1api.ApiListDatabasesRequestRequest) (*v3alpha1api.ListDatabasesResponse, error) {
+					currentPage++
+					return mockResp(currentPage)
+				}
+
+				client := &v3alpha1api.DefaultAPIServiceMock{
+					ListDatabasesRequestExecuteMock: &mockCall,
+				}
+
+				var actual *v3alpha1api.ListDatabase
+				var errDB error
+
+				if tt.wantDbName != "" {
+					actual, errDB = getDatabaseByName(
+						t.Context(),
+						client,
+						tt.projectID,
+						tt.region,
+						tt.instanceID,
+						tt.wantDbName,
+					)
+				} else if tt.wantDbID != 0 {
+					actual, errDB = getDatabaseById(
+						t.Context(),
+						client,
+						tt.projectID,
+						tt.region,
+						tt.instanceID,
+						int64(tt.wantDbID),
+					)
+				} else {
+					actual, errDB = getDatabase(
+						context.Background(),
+						client,
+						tt.projectID,
+						tt.region,
+						tt.instanceID,
+						func(_ v3alpha1api.ListDatabase) bool { return false },
+					)
+				}
+
+				if (errDB != nil) != tt.wantErr {
+					t.Errorf("getDatabaseByNameOrID() error = %v, wantErr %v", errDB, tt.wantErr)
+					return
+				}
+				if !tt.wantErr && tt.wantDbName != "" && actual != nil {
+					if actual.Name != tt.wantDbName {
+						t.Errorf("getDatabaseByNameOrID() got name = %v, want %v", actual.Name, tt.wantDbName)
+					}
+				}
+
+				if !tt.wantErr && tt.wantDbID != 0 && actual != nil {
+					if actual.Id != tt.wantDbID {
+						t.Errorf("getDatabaseByNameOrID() got id = %v, want %v", actual.Id, tt.wantDbID)
+					}
+				}
+			},
+		)
+	}
+}
+
+func TestCleanString(t *testing.T) {
+	testcases := []struct {
+		name     string
+		given    string
+		expected string
+	}{
+		{
+			name:     "should remove quotes",
+			given:    "\"quoted\"",
+			expected: "quoted",
+		},
+		{
+			name:     "should not change unquoted string",
+			given:    "unquoted",
+			expected: "unquoted",
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(
+			tc.name, func(t *testing.T) {
+				actual := cleanString(tc.given)
+				if diff := cmp.Diff(tc.expected, actual); diff != "" {
+					t.Errorf("string mismatch (-want +got):\n%s", diff)
+				}
+			},
+		)
+	}
+}

stackit/internal/services/postgresflexalpha/database/mapper.go

@@ -0,0 +1,93 @@
+package postgresflexalpha
+
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
+
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/utils"
+)
+
+// mapFields maps fields from a ListDatabase API response to a resourceModel for the data source.
+func mapFields(
+	source *v3alpha1api.ListDatabase,
+	model *dataSourceModel,
+	region string,
+) error {
+	if source == nil {
+		return fmt.Errorf("response is nil")
+	}
+	if source.Id == 0 {
+		return fmt.Errorf("id not present")
+	}
+	if model == nil {
+		return fmt.Errorf("model given is nil")
+	}
+
+	var databaseId int64
+	if model.DatabaseId.ValueInt64() != 0 {
+		databaseId = model.DatabaseId.ValueInt64()
+	} else if source.Id != 0 {
+		databaseId = int64(source.Id)
+	} else {
+		return fmt.Errorf("database id not present")
+	}
+
+	model.Id = types.Int64Value(databaseId)
+	model.DatabaseId = types.Int64Value(databaseId)
+	model.Name = types.StringValue(source.GetName())
+	model.Owner = types.StringValue(cleanString(source.Owner))
+	model.Region = types.StringValue(region)
+	model.ProjectId = types.StringValue(model.ProjectId.ValueString())
+	model.InstanceId = types.StringValue(model.InstanceId.ValueString())
+	model.TerraformID = utils.BuildInternalTerraformId(
+		model.ProjectId.ValueString(),
+		region,
+		model.InstanceId.ValueString(),
+		strconv.FormatInt(databaseId, 10),
+	)
+
+	return nil
+}
+
+// mapResourceFields maps fields from a GetDatabase API response to a resourceModel for the resource.
+func mapResourceFields(source *v3alpha1api.GetDatabaseResponse, model *resourceModel) error {
+	if source == nil {
+		return fmt.Errorf("response is nil")
+	}
+	if source.Id == 0 {
+		return fmt.Errorf("id not present")
+	}
+	if model == nil {
+		return fmt.Errorf("model input is nil")
+	}
+
+	var databaseId int64
+	if model.Id.ValueInt64() != 0 {
+		databaseId = model.Id.ValueInt64()
+	} else if source.Id != 0 {
+		databaseId = int64(source.Id)
+	} else {
+		return fmt.Errorf("database id not present")
+	}
+
+	model.Id = types.Int64Value(databaseId)
+	model.DatabaseId = types.Int64Value(databaseId)
+	model.Name = types.StringValue(source.GetName())
+	model.Owner = types.StringValue(cleanString(source.Owner))
+	return nil
+}
+
+// toCreatePayload converts the resource model to an API create payload.
+func toCreatePayload(model *resourceModel) (*v3alpha1api.CreateDatabaseRequestPayload, error) {
+	if model == nil {
+		return nil, fmt.Errorf("nil model")
+	}
+
+	return &v3alpha1api.CreateDatabaseRequestPayload{
+		Name:  model.Name.ValueString(),
+		Owner: model.Owner.ValueStringPointer(),
+	}, nil
+}

stackit/internal/services/postgresflexalpha/database/mapper_test.go

@@ -0,0 +1,248 @@
+package postgresflexalpha
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/stackitcloud/stackit-sdk-go/core/utils"
+
+	postgresflexalpha "github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
+
+	datasource "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/database/datasources_gen"
+)
+
+func TestMapFields(t *testing.T) {
+	type given struct {
+		source *postgresflexalpha.ListDatabase
+		model  *dataSourceModel
+		region string
+	}
+	type expected struct {
+		model *dataSourceModel
+		err   bool
+	}
+
+	testcases := []struct {
+		name     string
+		given    given
+		expected expected
+	}{
+		{
+			name: "should map fields correctly",
+			given: given{
+				source: &postgresflexalpha.ListDatabase{
+					Id:    int32(1),
+					Name:  "my-db",
+					Owner: "my-owner",
+				},
+				model: &dataSourceModel{
+					DatabaseModel: datasource.DatabaseModel{
+						ProjectId:  types.StringValue("my-project"),
+						InstanceId: types.StringValue("my-instance"),
+					},
+				},
+				region: "eu01",
+			},
+			expected: expected{
+				model: &dataSourceModel{
+					DatabaseModel: datasource.DatabaseModel{
+						Id:         types.Int64Value(1),
+						Name:       types.StringValue("my-db"),
+						Owner:      types.StringValue("my-owner"),
+						Region:     types.StringValue("eu01"),
+						DatabaseId: types.Int64Value(1),
+						InstanceId: types.StringValue("my-instance"),
+						ProjectId:  types.StringValue("my-project"),
+					},
+					TerraformID: types.StringValue("my-project,eu01,my-instance,1"),
+				},
+			},
+		},
+		{
+			name: "should preserve existing model ID",
+			given: given{
+				source: &postgresflexalpha.ListDatabase{
+					Id:   int32(1),
+					Name: "my-db",
+				},
+				model: &dataSourceModel{
+					DatabaseModel: datasource.DatabaseModel{
+						Id:         types.Int64Value(1),
+						ProjectId:  types.StringValue("my-project"),
+						InstanceId: types.StringValue("my-instance"),
+					},
+				},
+				region: "eu01",
+			},
+			expected: expected{
+				model: &dataSourceModel{
+					DatabaseModel: datasource.DatabaseModel{
+						Id:         types.Int64Value(1),
+						Name:       types.StringValue("my-db"),
+						Owner:      types.StringValue(""),
+						DatabaseId: types.Int64Value(1),
+						Region:     types.StringValue("eu01"),
+						InstanceId: types.StringValue("my-instance"),
+						ProjectId:  types.StringValue("my-project"),
+					},
+					TerraformID: types.StringValue("my-project,eu01,my-instance,1"),
+				},
+			},
+		},
+		{
+			name: "should fail on nil source",
+			given: given{
+				source: nil,
+				model:  &dataSourceModel{},
+			},
+			expected: expected{err: true},
+		},
+		{
+			name: "should fail on nil source ID",
+			given: given{
+				source: &postgresflexalpha.ListDatabase{Id: 0},
+				model:  &dataSourceModel{},
+			},
+			expected: expected{err: true},
+		},
+		{
+			name: "should fail on nil model",
+			given: given{
+				source: &postgresflexalpha.ListDatabase{Id: int32(1)},
+				model:  nil,
+			},
+			expected: expected{err: true},
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(
+			tc.name, func(t *testing.T) {
+				err := mapFields(tc.given.source, tc.given.model, tc.given.region)
+				if (err != nil) != tc.expected.err {
+					t.Fatalf("expected error: %v, got: %v", tc.expected.err, err)
+				}
+				if err == nil {
+					if diff := cmp.Diff(tc.expected.model, tc.given.model); diff != "" {
+						t.Errorf("model mismatch (-want +got):\n%s", diff)
+					}
+				}
+			},
+		)
+	}
+}
+
+func TestMapResourceFields(t *testing.T) {
+	type given struct {
+		source *postgresflexalpha.GetDatabaseResponse
+		model  *resourceModel
+	}
+	type expected struct {
+		model *resourceModel
+		err   bool
+	}
+
+	testcases := []struct {
+		name     string
+		given    given
+		expected expected
+	}{
+		{
+			name: "should map fields correctly",
+			given: given{
+				source: &postgresflexalpha.GetDatabaseResponse{
+					Id:    int32(1),
+					Name:  "my-db",
+					Owner: "my-owner",
+				},
+				model: &resourceModel{},
+			},
+			expected: expected{
+				model: &resourceModel{
+					Id:         types.Int64Value(1),
+					Name:       types.StringValue("my-db"),
+					Owner:      types.StringValue("my-owner"),
+					DatabaseId: types.Int64Value(1),
+				},
+			},
+		},
+		{
+			name: "should fail on nil source",
+			given: given{
+				source: nil,
+				model:  &resourceModel{},
+			},
+			expected: expected{err: true},
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(
+			tc.name, func(t *testing.T) {
+				err := mapResourceFields(tc.given.source, tc.given.model)
+				if (err != nil) != tc.expected.err {
+					t.Fatalf("expected error: %v, got: %v", tc.expected.err, err)
+				}
+				if err == nil {
+					if diff := cmp.Diff(tc.expected.model, tc.given.model); diff != "" {
+						t.Errorf("model mismatch (-want +got):\n%s", diff)
+					}
+				}
+			},
+		)
+	}
+}
+
+func TestToCreatePayload(t *testing.T) {
+	type given struct {
+		model *resourceModel
+	}
+	type expected struct {
+		payload *postgresflexalpha.CreateDatabaseRequestPayload
+		err     bool
+	}
+
+	testcases := []struct {
+		name     string
+		given    given
+		expected expected
+	}{
+		{
+			name: "should convert model to payload",
+			given: given{
+				model: &resourceModel{
+					Name:  types.StringValue("my-db"),
+					Owner: types.StringValue("my-owner"),
+				},
+			},
+			expected: expected{
+				payload: &postgresflexalpha.CreateDatabaseRequestPayload{
+					Name:  "my-db",
+					Owner: utils.Ptr("my-owner"),
+				},
+			},
+		},
+		{
+			name:     "should fail on nil model",
+			given:    given{model: nil},
+			expected: expected{err: true},
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(
+			tc.name, func(t *testing.T) {
+				actual, err := toCreatePayload(tc.given.model)
+				if (err != nil) != tc.expected.err {
+					t.Fatalf("expected error: %v, got: %v", tc.expected.err, err)
+				}
+				if err == nil {
+					if diff := cmp.Diff(tc.expected.payload, actual); diff != "" {
+						t.Errorf("payload mismatch (-want +got):\n%s", diff)
+					}
+				}
+			},
+		)
+	}
+}

stackit/internal/services/postgresflexalpha/database/planModifiers.yaml

@@ -0,0 +1,35 @@
+fields:
+  - name: 'id'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'database_id'
+    modifiers:
+      - 'UseStateForUnknown'
+    validators:
+      - validate.NoSeparator
+      - validate.UUID
+
+  - name: 'instance_id'
+    validators:
+      - validate.NoSeparator
+      - validate.UUID
+    modifiers:
+      - 'RequiresReplace'
+      - 'UseStateForUnknown'
+
+  - name: 'project_id'
+    modifiers:
+      - 'RequiresReplace'
+      - 'UseStateForUnknown'
+    validators:
+      - validate.NoSeparator
+      - validate.UUID
+
+  - name: 'name'
+    validators:
+      - validate.NoSeparator
+
+  - name: 'region'
+    modifiers:
+      - 'RequiresReplace'

stackit/internal/services/postgresflexalpha/database/resource.go

@@ -0,0 +1,625 @@
+package postgresflexalpha
+
+import (
+	"context"
+	_ "embed"
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/hashicorp/terraform-plugin-framework/path"
+	"github.com/hashicorp/terraform-plugin-framework/resource"
+	"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/services/postgresflex/v3alpha1api"
+
+	"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"
+	postgresflexalphaResGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/database/resources_gen"
+	postgresflexUtils "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/utils"
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/utils"
+	postgresflexalphaWait "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/wait/postgresflexalpha"
+)
+
+var (
+	// Ensure the implementation satisfies the expected interfaces.
+	_ resource.Resource                = &databaseResource{}
+	_ resource.ResourceWithConfigure   = &databaseResource{}
+	_ resource.ResourceWithImportState = &databaseResource{}
+	_ resource.ResourceWithModifyPlan  = &databaseResource{}
+	_ resource.ResourceWithIdentity    = &databaseResource{}
+
+	// Error message constants
+	extractErrorSummary = "extracting failed"
+	extractErrorMessage = "Extracting identity data: %v"
+)
+
+// NewDatabaseResource is a helper function to simplify the provider implementation.
+func NewDatabaseResource() resource.Resource {
+	return &databaseResource{}
+}
+
+// resourceModel describes the resource data model.
+type resourceModel = postgresflexalphaResGen.DatabaseModel
+
+// DatabaseResourceIdentityModel describes the resource's identity attributes.
+type DatabaseResourceIdentityModel struct {
+	ProjectID  types.String `tfsdk:"project_id"`
+	Region     types.String `tfsdk:"region"`
+	InstanceID types.String `tfsdk:"instance_id"`
+	DatabaseID types.Int64  `tfsdk:"database_id"`
+}
+
+// databaseResource is the resource implementation.
+type databaseResource struct {
+	client       *v3alpha1api.APIClient
+	providerData core.ProviderData
+}
+
+// ModifyPlan adjusts the plan to set the correct region.
+func (r *databaseResource) ModifyPlan(
+	ctx context.Context,
+	req resource.ModifyPlanRequest,
+	resp *resource.ModifyPlanResponse,
+) { // nolint:gocritic // function signature required by Terraform
+	var configModel resourceModel
+	// skip initial empty configuration to avoid follow-up errors
+	if req.Config.Raw.IsNull() {
+		return
+	}
+	resp.Diagnostics.Append(req.Config.Get(ctx, &configModel)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	var planModel resourceModel
+	resp.Diagnostics.Append(req.Plan.Get(ctx, &planModel)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	utils.AdaptRegion(ctx, configModel.Region, &planModel.Region, r.providerData.GetRegion(), resp)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	resp.Diagnostics.Append(resp.Plan.Set(ctx, planModel)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+}
+
+// Metadata returns the resource type name.
+func (r *databaseResource) Metadata(_ context.Context, req resource.MetadataRequest, resp *resource.MetadataResponse) {
+	resp.TypeName = req.ProviderTypeName + "_postgresflexalpha_database"
+}
+
+// Configure adds the provider configured client to the resource.
+func (r *databaseResource) 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
+	}
+
+	apiClient := postgresflexUtils.ConfigureClient(ctx, &r.providerData, &resp.Diagnostics)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	r.client = apiClient
+	tflog.Info(ctx, "Postgres Flex database client configured")
+}
+
+//go:embed planModifiers.yaml
+var modifiersFileByte []byte
+
+// Schema defines the schema for the resource.
+func (r *databaseResource) Schema(ctx context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
+	s := postgresflexalphaResGen.DatabaseResourceSchema(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 *databaseResource) IdentitySchema(
+	_ context.Context,
+	_ resource.IdentitySchemaRequest,
+	response *resource.IdentitySchemaResponse,
+) {
+	response.IdentitySchema = identityschema.Schema{
+		Attributes: map[string]identityschema.Attribute{
+			"project_id": identityschema.StringAttribute{
+				RequiredForImport: true,
+			},
+			"region": identityschema.StringAttribute{
+				RequiredForImport: true,
+			},
+			"instance_id": identityschema.StringAttribute{
+				RequiredForImport: true,
+			},
+			"database_id": identityschema.Int64Attribute{
+				RequiredForImport: true,
+			},
+		},
+	}
+}
+
+// Create creates the resource and sets the initial Terraform state.
+func (r *databaseResource) Create(
+	ctx context.Context,
+	req resource.CreateRequest,
+	resp *resource.CreateResponse,
+) { // nolint:gocritic // function signature required by Terraform
+	const funcErrorSummary = "[database CREATE] error"
+	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()
+	region := model.Region.ValueString()
+	instanceId := model.InstanceId.ValueString()
+
+	ctx = tflog.SetField(ctx, "project_id", projectId)
+	ctx = tflog.SetField(ctx, "instance_id", instanceId)
+	ctx = tflog.SetField(ctx, "region", region)
+
+	// Generate API request body from model
+	payload, err := toCreatePayload(&model)
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			funcErrorSummary,
+			fmt.Sprintf("Creating API payload: %v", err),
+		)
+		return
+	}
+	// Create new database
+	databaseResp, err := r.client.DefaultAPI.CreateDatabaseRequest(
+		ctx,
+		projectId,
+		region,
+		instanceId,
+	).CreateDatabaseRequestPayload(*payload).Execute()
+	if err != nil {
+		core.LogAndAddError(ctx, &resp.Diagnostics, funcErrorSummary, fmt.Sprintf("Calling API: %v", err))
+		return
+	}
+
+	dbID, ok := databaseResp.GetIdOk()
+	if !ok {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			funcErrorSummary,
+			"API didn't return database Id. A database might although have been created",
+		)
+		return
+	}
+	databaseId := int64(*dbID)
+	ctx = tflog.SetField(ctx, "database_id", databaseId)
+	ctx = core.LogResponse(ctx)
+
+	// Save identity into Terraform state
+	identity := DatabaseResourceIdentityModel{
+		ProjectID:  types.StringValue(projectId),
+		Region:     types.StringValue(region),
+		InstanceID: types.StringValue(instanceId),
+		DatabaseID: types.Int64Value(databaseId),
+	}
+	resp.Diagnostics.Append(resp.Identity.Set(ctx, identity)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	database, err := postgresflexalphaWait.GetDatabaseByIdWaitHandler(ctx, r.client.DefaultAPI, projectId, instanceId, region, databaseId).
+		SetTimeout(15 * time.Minute).
+		SetSleepBeforeWait(15 * time.Second).
+		WaitWithContext(ctx)
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			funcErrorSummary,
+			fmt.Sprintf("Getting database details after creation: %v", err),
+		)
+		return
+	}
+
+	// Map response body to schema
+	err = mapResourceFields(database, &model)
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			funcErrorSummary,
+			fmt.Sprintf("map resource fields: %v", err),
+		)
+		return
+	}
+
+	// Set state to fully populated data
+	resp.Diagnostics.Append(resp.State.Set(ctx, model)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	tflog.Info(ctx, "Postgres Flex database created")
+}
+
+// Read refreshes the Terraform state with the latest data.
+func (r *databaseResource) 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()
+	region := model.Region.ValueString()
+	databaseId := model.DatabaseId.ValueInt64()
+
+	ctx = tflog.SetField(ctx, "project_id", projectId)
+	ctx = tflog.SetField(ctx, "instance_id", instanceId)
+	ctx = tflog.SetField(ctx, "region", region)
+	ctx = tflog.SetField(ctx, "database_id", databaseId)
+
+	databaseResp, err := postgresflexalphaWait.GetDatabaseByIdWaitHandler(ctx, r.client.DefaultAPI, projectId, instanceId, region, databaseId).
+		SetTimeout(15 * time.Minute).
+		SetSleepBeforeWait(15 * time.Second).
+		WaitWithContext(ctx)
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"Error creating database",
+			fmt.Sprintf("Getting database details after creation: %v", err),
+		)
+		return
+	}
+
+	ctx = core.LogResponse(ctx)
+
+	// Map response body to schema
+	err = mapResourceFields(databaseResp, &model)
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"Error reading database",
+			fmt.Sprintf("Processing API payload: %v", err),
+		)
+		return
+	}
+
+	// Save identity into Terraform state
+	identity := DatabaseResourceIdentityModel{
+		ProjectID:  types.StringValue(projectId),
+		Region:     types.StringValue(region),
+		InstanceID: types.StringValue(instanceId),
+		DatabaseID: types.Int64Value(int64(databaseResp.GetId())),
+	}
+	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...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	tflog.Info(ctx, "Postgres Flex database read")
+}
+
+// Update updates the resource and sets the updated Terraform state on success.
+func (r *databaseResource) Update(
+	ctx context.Context,
+	req resource.UpdateRequest,
+	resp *resource.UpdateResponse,
+) {
+	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()
+	databaseId := model.DatabaseId.ValueInt64()
+
+	ctx = tflog.SetField(ctx, "project_id", projectId)
+	ctx = tflog.SetField(ctx, "instance_id", instanceId)
+	ctx = tflog.SetField(ctx, "region", region)
+	ctx = tflog.SetField(ctx, "database_id", databaseId)
+
+	// Retrieve values from state
+	var stateModel resourceModel
+	diags = req.State.Get(ctx, &stateModel)
+	resp.Diagnostics.Append(diags...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	modified := false
+	var payload v3alpha1api.UpdateDatabasePartiallyRequestPayload
+	if stateModel.Name != model.Name {
+		payload.Name = model.Name.ValueStringPointer()
+		modified = true
+	}
+
+	if stateModel.Owner != model.Owner {
+		payload.Owner = model.Owner.ValueStringPointer()
+		modified = true
+	}
+
+	if !modified {
+		tflog.Info(ctx, "no modification detected")
+		return
+	}
+
+	if databaseId > math.MaxInt32 {
+		core.LogAndAddError(ctx, &resp.Diagnostics, "error updating database", "databaseID out of bounds for int32")
+		return
+	}
+	databaseID32 := int32(databaseId) //nolint:gosec // TODO
+	// Update existing database
+	err := r.client.DefaultAPI.UpdateDatabasePartiallyRequest(
+		ctx,
+		projectId,
+		region,
+		instanceId,
+		databaseID32,
+	).UpdateDatabasePartiallyRequestPayload(payload).Execute()
+	if err != nil {
+		core.LogAndAddError(ctx, &resp.Diagnostics, "error updating database", err.Error())
+		return
+	}
+
+	ctx = core.LogResponse(ctx)
+
+	databaseResp, err := postgresflexalphaWait.GetDatabaseByIdWaitHandler(ctx, r.client.DefaultAPI, projectId, instanceId, region, databaseId).
+		SetTimeout(15 * time.Minute).
+		SetSleepBeforeWait(15 * time.Second).
+		WaitWithContext(ctx)
+	if err != nil {
+		core.LogAndAddError(ctx, &resp.Diagnostics, "error updating database", err.Error())
+		return
+	}
+
+	ctx = core.LogResponse(ctx)
+
+	// Map response body to schema
+	err = mapResourceFields(databaseResp, &model)
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"Error reading database",
+			fmt.Sprintf("Processing API payload: %v", err),
+		)
+		return
+	}
+
+	// Save identity into Terraform state
+	identity := DatabaseResourceIdentityModel{
+		ProjectID:  types.StringValue(projectId),
+		Region:     types.StringValue(region),
+		InstanceID: types.StringValue(instanceId),
+		DatabaseID: types.Int64Value(databaseId),
+	}
+	resp.Diagnostics.Append(resp.Identity.Set(ctx, identity)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	// Set state to fully populated data
+	resp.Diagnostics.Append(resp.State.Set(ctx, &model)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	tflog.Info(ctx, "Postgres Flex database updated")
+}
+
+// Delete deletes the resource and removes the Terraform state on success.
+func (r *databaseResource) Delete(
+	ctx context.Context,
+	req resource.DeleteRequest,
+	resp *resource.DeleteResponse,
+) { // 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
+	}
+
+	// Read identity data
+	var identityData DatabaseResourceIdentityModel
+	resp.Diagnostics.Append(req.Identity.Get(ctx, &identityData)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	ctx = core.InitProviderContext(ctx)
+
+	projectId, region, instanceId, databaseId64, errExt := r.extractIdentityData(model, identityData)
+	if errExt != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			extractErrorSummary,
+			fmt.Sprintf(extractErrorMessage, errExt),
+		)
+	}
+
+	if databaseId64 > math.MaxInt32 {
+		core.LogAndAddError(ctx, &resp.Diagnostics, "Error in type conversion", "int value too large (databaseId)")
+		return
+	}
+	databaseId := int32(databaseId64) // nolint:gosec // check is performed above
+	ctx = tflog.SetField(ctx, "project_id", projectId)
+	ctx = tflog.SetField(ctx, "instance_id", instanceId)
+	ctx = tflog.SetField(ctx, "region", region)
+	ctx = tflog.SetField(ctx, "database_id", databaseId)
+
+	// Delete existing record set
+	err := r.client.DefaultAPI.DeleteDatabaseRequest(ctx, projectId, region, instanceId, databaseId).Execute()
+	if err != nil {
+		core.LogAndAddError(ctx, &resp.Diagnostics, "Error deleting database", fmt.Sprintf("Calling API: %v", err))
+	}
+
+	ctx = core.LogResponse(ctx)
+
+	tflog.Info(ctx, "Postgres Flex database deleted")
+}
+
+// ImportState imports a resource into the Terraform state on success.
+// The expected import identifier format is: [project_id],[region],[instance_id],[database_id]
+func (r *databaseResource) ImportState(
+	ctx context.Context,
+	req resource.ImportStateRequest,
+	resp *resource.ImportStateResponse,
+) {
+	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 database",
+				fmt.Sprintf(
+					"Expected import identifier with format [project_id],[region],[instance_id],[database_id], got %q",
+					req.ID,
+				),
+			)
+			return
+		}
+
+		databaseId, err := strconv.ParseInt(idParts[3], 10, 64)
+		if err != nil {
+			core.LogAndAddError(
+				ctx,
+				&resp.Diagnostics,
+				"Error importing database",
+				fmt.Sprintf("Invalid database_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("database_id"), databaseId)...)
+
+		core.LogAndAddWarning(
+			ctx,
+			&resp.Diagnostics,
+			"Postgresflex 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.",
+		)
+
+		tflog.Info(ctx, "Postgres Flex database state imported")
+
+		return
+	}
+
+	// If no ID is provided, attempt to read identity attributes from the import configuration
+	var identityData DatabaseResourceIdentityModel
+	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()
+	databaseId := identityData.DatabaseID.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("database_id"), databaseId)...)
+
+	tflog.Info(ctx, "Postgres Flex database state imported")
+}
+
+// extractIdentityData extracts essential identifiers from the resource model, falling back to the identity model.
+func (r *databaseResource) extractIdentityData(
+	model resourceModel,
+	identity DatabaseResourceIdentityModel,
+) (projectId, region, instanceId string, databaseId int64, err error) {
+	if !model.DatabaseId.IsNull() && !model.DatabaseId.IsUnknown() {
+		databaseId = model.DatabaseId.ValueInt64()
+	} else {
+		if identity.DatabaseID.IsNull() || identity.DatabaseID.IsUnknown() {
+			return "", "", "", 0, fmt.Errorf("database_id not found in config")
+		}
+		databaseId = identity.DatabaseID.ValueInt64()
+	}
+
+	if !model.ProjectId.IsNull() && !model.ProjectId.IsUnknown() {
+		projectId = model.ProjectId.ValueString()
+	} else {
+		if identity.ProjectID.IsNull() || identity.ProjectID.IsUnknown() {
+			return "", "", "", 0, fmt.Errorf("project_id not found in config")
+		}
+		projectId = identity.ProjectID.ValueString()
+	}
+
+	if !model.Region.IsNull() && !model.Region.IsUnknown() {
+		region = r.providerData.GetRegionWithOverride(model.Region)
+	} else {
+		if identity.Region.IsNull() || identity.Region.IsUnknown() {
+			return "", "", "", 0, fmt.Errorf("region not found in config")
+		}
+		region = r.providerData.GetRegionWithOverride(identity.Region)
+	}
+
+	if !model.InstanceId.IsNull() && !model.InstanceId.IsUnknown() {
+		instanceId = model.InstanceId.ValueString()
+	} else {
+		if identity.InstanceID.IsNull() || identity.InstanceID.IsUnknown() {
+			return "", "", "", 0, fmt.Errorf("instance_id not found in config")
+		}
+		instanceId = identity.InstanceID.ValueString()
+	}
+	return projectId, region, instanceId, databaseId, nil
+}

stackit/internal/services/postgresflexalpha/database/resource.go.bak

@@ -1,447 +0,0 @@
-package postgresflexa
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http"
-	"strings"
-
-	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex"
-	"github.com/stackitcloud/terraform-provider-stackit/pkg/postgresflexalpha"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/conversion"
-	postgresflexUtils "github.com/stackitcloud/terraform-provider-stackit/stackit/internal/services/postgresflexalpha/utils"
-
-	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
-	"github.com/hashicorp/terraform-plugin-log/tflog"
-	"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/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/stringplanmodifier"
-	"github.com/hashicorp/terraform-plugin-framework/types"
-	"github.com/stackitcloud/stackit-sdk-go/core/oapierror"
-)
-
-// Ensure the implementation satisfies the expected interfaces.
-var (
-	_ resource.Resource                = &databaseResource{}
-	_ resource.ResourceWithConfigure   = &databaseResource{}
-	_ resource.ResourceWithImportState = &databaseResource{}
-	_ resource.ResourceWithModifyPlan  = &databaseResource{}
-)
-
-type Model struct {
-	Id         types.String    `tfsdk:"id"` // needed by TF
-	DatabaseId types.String    `tfsdk:"database_id"`
-	InstanceId types.String    `tfsdk:"instance_id"`
-	ProjectId  types.String    `tfsdk:"project_id"`
-	Name       types.String    `tfsdk:"name"`
-	Owner      types.String    `tfsdk:"owner"`
-	Region     types.String    `tfsdk:"region"`
-	Encryption encryptionModel `tfsdk:"encryption"`
-}
-
-type encryptionModel struct {
-	KeyId types.String `tfsdk:"key_id"`
-	//keyringid = xxxx
-	//keyversion = xxxx
-	//serviceaccount = xxxx
-}
-
-// NewDatabaseResource is a helper function to simplify the provider implementation.
-func NewDatabaseResource() resource.Resource {
-	return &databaseResource{}
-}
-
-// databaseResource is the resource implementation.
-type databaseResource struct {
-	client       *postgresflexalpha.APIClient
-	providerData core.ProviderData
-}
-
-// ModifyPlan implements resource.ResourceWithModifyPlan.
-// Use the modifier to set the effective region in the current plan.
-func (r *databaseResource) ModifyPlan(ctx context.Context, req resource.ModifyPlanRequest, resp *resource.ModifyPlanResponse) { // nolint:gocritic // function signature required by Terraform
-	var configModel Model
-	// skip initial empty configuration to avoid follow-up errors
-	if req.Config.Raw.IsNull() {
-		return
-	}
-	resp.Diagnostics.Append(req.Config.Get(ctx, &configModel)...)
-	if resp.Diagnostics.HasError() {
-		return
-	}
-
-	var planModel Model
-	resp.Diagnostics.Append(req.Plan.Get(ctx, &planModel)...)
-	if resp.Diagnostics.HasError() {
-		return
-	}
-
-	utils.AdaptRegion(ctx, configModel.Region, &planModel.Region, r.providerData.GetRegion(), resp)
-	if resp.Diagnostics.HasError() {
-		return
-	}
-
-	resp.Diagnostics.Append(resp.Plan.Set(ctx, planModel)...)
-	if resp.Diagnostics.HasError() {
-		return
-	}
-}
-
-// Metadata returns the resource type name.
-func (r *databaseResource) Metadata(_ context.Context, req resource.MetadataRequest, resp *resource.MetadataResponse) {
-	resp.TypeName = req.ProviderTypeName + "_postgresflex_database"
-}
-
-// Configure adds the provider configured client to the resource.
-func (r *databaseResource) 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
-	}
-
-	apiClient := postgresflexUtils.ConfigureClient(ctx, &r.providerData, &resp.Diagnostics)
-	if resp.Diagnostics.HasError() {
-		return
-	}
-	r.client = apiClient
-	tflog.Info(ctx, "Postgres Flex database client configured")
-}
-
-// Schema defines the schema for the resource.
-func (r *databaseResource) Schema(_ context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
-	descriptions := map[string]string{
-		"main":        "Postgres Flex database 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`,`database_id`\".",
-		"database_id": "Database ID.",
-		"instance_id": "ID of the Postgres Flex instance.",
-		"project_id":  "STACKIT project ID to which the instance is associated.",
-		"name":        "Database name.",
-		"owner":       "Username of the database owner.",
-		"region":      "The resource region. If not defined, the provider region is used.",
-	}
-
-	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(),
-				},
-			},
-			"database_id": schema.StringAttribute{
-				Description: descriptions["database_id"],
-				Computed:    true,
-				PlanModifiers: []planmodifier.String{
-					stringplanmodifier.UseStateForUnknown(),
-				},
-				Validators: []validator.String{
-					validate.NoSeparator(),
-				},
-			},
-			"instance_id": schema.StringAttribute{
-				Description: descriptions["instance_id"],
-				Required:    true,
-				PlanModifiers: []planmodifier.String{
-					stringplanmodifier.RequiresReplace(),
-					stringplanmodifier.UseStateForUnknown(),
-				},
-				Validators: []validator.String{
-					validate.UUID(),
-					validate.NoSeparator(),
-				},
-			},
-			"project_id": schema.StringAttribute{
-				Description: descriptions["project_id"],
-				Required:    true,
-				PlanModifiers: []planmodifier.String{
-					stringplanmodifier.RequiresReplace(),
-					stringplanmodifier.UseStateForUnknown(),
-				},
-				Validators: []validator.String{
-					validate.UUID(),
-					validate.NoSeparator(),
-				},
-			},
-			"name": schema.StringAttribute{
-				Description: descriptions["name"],
-				Required:    true,
-				PlanModifiers: []planmodifier.String{
-					stringplanmodifier.RequiresReplace(),
-				},
-			},
-			"owner": schema.StringAttribute{
-				Description: descriptions["owner"],
-				Required:    true,
-				PlanModifiers: []planmodifier.String{
-					stringplanmodifier.RequiresReplace(),
-				},
-			},
-			"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(),
-				},
-			},
-		},
-	}
-}
-
-// Create creates the resource and sets the initial Terraform state.
-func (r *databaseResource) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) { // nolint:gocritic // function signature required by Terraform
-	var model Model
-	diags := req.Plan.Get(ctx, &model)
-	resp.Diagnostics.Append(diags...)
-	if resp.Diagnostics.HasError() {
-		return
-	}
-
-	ctx = core.InitProviderContext(ctx)
-
-	projectId := model.ProjectId.ValueString()
-	region := model.Region.ValueString()
-	instanceId := model.InstanceId.ValueString()
-	ctx = tflog.SetField(ctx, "project_id", projectId)
-	ctx = tflog.SetField(ctx, "instance_id", instanceId)
-	ctx = tflog.SetField(ctx, "region", region)
-
-	// Generate API request body from model
-	payload, err := toCreatePayload(&model)
-	if err != nil {
-		core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating database", fmt.Sprintf("Creating API payload: %v", err))
-		return
-	}
-	// Create new database
-	databaseResp, err := r.client.CreateDatabaseRequest(ctx, projectId, region, instanceId).CreateDatabaseRequestPayload(*payload).Execute()
-	if err != nil {
-		core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating database", fmt.Sprintf("Calling API: %v", err))
-		return
-	}
-
-	ctx = core.LogResponse(ctx)
-
-	if databaseResp == nil || databaseResp.Id == nil || *databaseResp.Id == "" {
-		core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating database", "API didn't return database Id. A database might have been created")
-		return
-	}
-	databaseId := *databaseResp.Id
-	ctx = tflog.SetField(ctx, "database_id", databaseId)
-
-	database, err := getDatabase(ctx, r.client, projectId, region, instanceId, databaseId)
-	if err != nil {
-		core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating database", fmt.Sprintf("Getting database details after creation: %v", err))
-		return
-	}
-
-	// Map response body to schema
-	err = mapFields(database, &model, region)
-	if err != nil {
-		core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating database", 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, "Postgres Flex database created")
-}
-
-// Read refreshes the Terraform state with the latest data.
-func (r *databaseResource) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse) { // nolint:gocritic // function signature required by Terraform
-	var model Model
-	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()
-	databaseId := model.DatabaseId.ValueString()
-	region := r.providerData.GetRegionWithOverride(model.Region)
-	ctx = tflog.SetField(ctx, "project_id", projectId)
-	ctx = tflog.SetField(ctx, "instance_id", instanceId)
-	ctx = tflog.SetField(ctx, "database_id", databaseId)
-	ctx = tflog.SetField(ctx, "region", region)
-
-	databaseResp, err := getDatabase(ctx, r.client, projectId, region, instanceId, databaseId)
-	if err != nil {
-		oapiErr, ok := err.(*oapierror.GenericOpenAPIError) //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) || errors.Is(err, databaseNotFoundErr) {
-			resp.State.RemoveResource(ctx)
-			return
-		}
-		core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading database", fmt.Sprintf("Calling API: %v", err))
-		return
-	}
-
-	ctx = core.LogResponse(ctx)
-
-	// Map response body to schema
-	err = mapFields(databaseResp, &model, region)
-	if err != nil {
-		core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading database", 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, "Postgres Flex database read")
-}
-
-// Update updates the resource and sets the updated Terraform state on success.
-func (r *databaseResource) 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 database", "Database can't be updated")
-}
-
-// Delete deletes the resource and removes the Terraform state on success.
-func (r *databaseResource) Delete(ctx context.Context, req resource.DeleteRequest, resp *resource.DeleteResponse) { // nolint:gocritic // function signature required by Terraform
-	// Retrieve values from plan
-	var model Model
-	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()
-	databaseId := model.DatabaseId.ValueString()
-	region := model.Region.ValueString()
-	ctx = tflog.SetField(ctx, "project_id", projectId)
-	ctx = tflog.SetField(ctx, "instance_id", instanceId)
-	ctx = tflog.SetField(ctx, "database_id", databaseId)
-	ctx = tflog.SetField(ctx, "region", region)
-
-	// Delete existing record set
-	err := r.client.DeleteDatabase(ctx, projectId, region, instanceId, databaseId).Execute()
-	if err != nil {
-		core.LogAndAddError(ctx, &resp.Diagnostics, "Error deleting database", fmt.Sprintf("Calling API: %v", err))
-	}
-
-	ctx = core.LogResponse(ctx)
-
-	tflog.Info(ctx, "Postgres Flex database 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 *databaseResource) ImportState(ctx context.Context, 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 database",
-			fmt.Sprintf("Expected import identifier with format [project_id],[region],[instance_id],[database_id], got %q", req.ID),
-		)
-		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("database_id"), idParts[3])...)
-	core.LogAndAddWarning(ctx, &resp.Diagnostics,
-		"Postgresflex 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.",
-	)
-	tflog.Info(ctx, "Postgres Flex database state imported")
-}
-
-func mapFields(databaseResp *postgresflex.InstanceDatabase, model *Model, region string) error {
-	if databaseResp == nil {
-		return fmt.Errorf("response is nil")
-	}
-	if databaseResp.Id == nil || *databaseResp.Id == "" {
-		return fmt.Errorf("id not present")
-	}
-	if model == nil {
-		return fmt.Errorf("model input is nil")
-	}
-
-	var databaseId string
-	if model.DatabaseId.ValueString() != "" {
-		databaseId = model.DatabaseId.ValueString()
-	} else if databaseResp.Id != nil {
-		databaseId = *databaseResp.Id
-	} else {
-		return fmt.Errorf("database id not present")
-	}
-	model.Id = utils.BuildInternalTerraformId(
-		model.ProjectId.ValueString(), region, model.InstanceId.ValueString(), databaseId,
-	)
-	model.DatabaseId = types.StringValue(databaseId)
-	model.Name = types.StringPointerValue(databaseResp.Name)
-	model.Region = types.StringValue(region)
-
-	if databaseResp.Options != nil {
-		owner, ok := (*databaseResp.Options)["owner"]
-		if ok {
-			ownerStr, ok := owner.(string)
-			if !ok {
-				return fmt.Errorf("owner is not a string")
-			}
-			// If the field is returned between with quotes, we trim them to prevent an inconsistent result after apply
-			ownerStr = strings.TrimPrefix(ownerStr, `"`)
-			ownerStr = strings.TrimSuffix(ownerStr, `"`)
-			model.Owner = types.StringValue(ownerStr)
-		}
-	}
-
-	return nil
-}
-
-func toCreatePayload(model *Model) (*postgresflexalpha.CreateDatabaseRequestPayload, error) {
-	if model == nil {
-		return nil, fmt.Errorf("nil model")
-	}
-
-	return &postgresflexalpha.CreateDatabaseRequestPayload{
-		Name: model.Name.ValueStringPointer(),
-		// TODO
-		//Options: &map[string]string{
-		//	"owner": model.Owner.ValueString(),
-		//},
-	}, nil
-}
-
-var databaseNotFoundErr = errors.New("database not found")
-
-// The API does not have a GetDatabase endpoint, only ListDatabases
-func getDatabase(ctx context.Context, client *postgresflexalpha.APIClient, projectId, region, instanceId, databaseId string) (*postgresflex.InstanceDatabase, error) {
-	resp, err := client.ListDatabasesRequest(ctx, projectId, region, instanceId).Execute()
-	if err != nil {
-		return nil, err
-	}
-	if resp == nil || resp.Databases == nil {
-		return nil, fmt.Errorf("response is nil")
-	}
-	for _, database := range *resp.Databases {
-		if database.Id != nil && *database.Id == databaseId {
-			return &database, nil
-		}
-	}
-	return nil, databaseNotFoundErr
-}

stackit/internal/services/postgresflexalpha/database/resource_test.go.bak

@@ -1,192 +0,0 @@
-// Copyright (c) STACKIT
-
-package postgresflexa
-
-import (
-	"testing"
-
-	"github.com/google/go-cmp/cmp"
-	"github.com/hashicorp/terraform-plugin-framework/types"
-	"github.com/stackitcloud/stackit-sdk-go/core/utils"
-	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex"
-)
-
-func TestMapFields(t *testing.T) {
-	const testRegion = "region"
-	tests := []struct {
-		description string
-		input       *postgresflex.InstanceDatabase
-		region      string
-		expected    Model
-		isValid     bool
-	}{
-		{
-			"default_values",
-			&postgresflex.InstanceDatabase{
-				Id: utils.Ptr("uid"),
-			},
-			testRegion,
-			Model{
-				Id:         types.StringValue("pid,region,iid,uid"),
-				DatabaseId: types.StringValue("uid"),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Name:       types.StringNull(),
-				Owner:      types.StringNull(),
-				Region:     types.StringValue(testRegion),
-			},
-			true,
-		},
-		{
-			"simple_values",
-			&postgresflex.InstanceDatabase{
-				Id:   utils.Ptr("uid"),
-				Name: utils.Ptr("dbname"),
-				Options: &map[string]interface{}{
-					"owner": "username",
-				},
-			},
-			testRegion,
-			Model{
-				Id:         types.StringValue("pid,region,iid,uid"),
-				DatabaseId: types.StringValue("uid"),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Name:       types.StringValue("dbname"),
-				Owner:      types.StringValue("username"),
-				Region:     types.StringValue(testRegion),
-			},
-			true,
-		},
-		{
-			"null_fields_and_int_conversions",
-			&postgresflex.InstanceDatabase{
-				Id:   utils.Ptr("uid"),
-				Name: utils.Ptr(""),
-				Options: &map[string]interface{}{
-					"owner": "",
-				},
-			},
-			testRegion,
-			Model{
-				Id:         types.StringValue("pid,region,iid,uid"),
-				DatabaseId: types.StringValue("uid"),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Name:       types.StringValue(""),
-				Owner:      types.StringValue(""),
-				Region:     types.StringValue(testRegion),
-			},
-			true,
-		},
-		{
-			"nil_response",
-			nil,
-			testRegion,
-			Model{},
-			false,
-		},
-		{
-			"empty_response",
-			&postgresflex.InstanceDatabase{},
-			testRegion,
-			Model{},
-			false,
-		},
-		{
-			"no_resource_id",
-			&postgresflex.InstanceDatabase{
-				Id:   utils.Ptr(""),
-				Name: utils.Ptr("dbname"),
-				Options: &map[string]interface{}{
-					"owner": "username",
-				},
-			},
-			testRegion,
-			Model{},
-			false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.description, func(t *testing.T) {
-			state := &Model{
-				ProjectId:  tt.expected.ProjectId,
-				InstanceId: tt.expected.InstanceId,
-			}
-			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       *Model
-		expected    *postgresflex.CreateDatabasePayload
-		isValid     bool
-	}{
-		{
-			"default_values",
-			&Model{
-				Name:  types.StringValue("dbname"),
-				Owner: types.StringValue("username"),
-			},
-			&postgresflex.CreateDatabasePayload{
-				Name: utils.Ptr("dbname"),
-				Options: &map[string]string{
-					"owner": "username",
-				},
-			},
-			true,
-		},
-		{
-			"null_fields",
-			&Model{
-				Name:  types.StringNull(),
-				Owner: types.StringNull(),
-			},
-			&postgresflex.CreateDatabasePayload{
-				Name: nil,
-				Options: &map[string]string{
-					"owner": "",
-				},
-			},
-			true,
-		},
-		{
-			"nil_model",
-			nil,
-			nil,
-			false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.description, func(t *testing.T) {
-			output, err := toCreatePayload(tt.input)
-			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/postgresflexalpha/database/resources_gen/database_resource_gen.go

@@ -0,0 +1,74 @@
+// Code generated by terraform-plugin-framework-generator DO NOT EDIT.
+
+package postgresflexalpha
+
+import (
+	"context"
+	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
+	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema"
+)
+
+func DatabaseResourceSchema(ctx context.Context) schema.Schema {
+	return schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"database_id": schema.Int64Attribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The ID of the database.",
+				MarkdownDescription: "The ID of the database.",
+			},
+			"id": schema.Int64Attribute{
+				Computed:            true,
+				Description:         "The id of the database.",
+				MarkdownDescription: "The id of the database.",
+			},
+			"instance_id": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The ID of the instance.",
+				MarkdownDescription: "The ID of the instance.",
+			},
+			"name": schema.StringAttribute{
+				Required:            true,
+				Description:         "The name of the database.",
+				MarkdownDescription: "The name of the database.",
+			},
+			"owner": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The owner of the database.",
+				MarkdownDescription: "The owner of the database.",
+			},
+			"project_id": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The STACKIT project ID.",
+				MarkdownDescription: "The STACKIT project ID.",
+			},
+			"region": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The region which should be addressed",
+				MarkdownDescription: "The region which should be addressed",
+				Validators: []validator.String{
+					stringvalidator.OneOf(
+						"eu01",
+					),
+				},
+			},
+		},
+	}
+}
+
+type DatabaseModel struct {
+	DatabaseId types.Int64  `tfsdk:"database_id"`
+	Id         types.Int64  `tfsdk:"id"`
+	InstanceId types.String `tfsdk:"instance_id"`
+	Name       types.String `tfsdk:"name"`
+	Owner      types.String `tfsdk:"owner"`
+	ProjectId  types.String `tfsdk:"project_id"`
+	Region     types.String `tfsdk:"region"`
+}

stackit/internal/services/postgresflexalpha/flavor/datasource.go

@@ -0,0 +1,253 @@
+package postgresflexalphaflavor
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-framework/attr"
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
+	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
+
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/conversion"
+	postgresflexalphaGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/flavors/datasources_gen"
+	postgresflexUtils "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/utils"
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/utils"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource"
+	"github.com/hashicorp/terraform-plugin-log/tflog"
+
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/core"
+)
+
+// Ensure the implementation satisfies the expected interfaces.
+var (
+	_ datasource.DataSource = &flavorDataSource{}
+)
+
+type FlavorModel struct {
+	ProjectId      types.String `tfsdk:"project_id"`
+	Region         types.String `tfsdk:"region"`
+	StorageClass   types.String `tfsdk:"storage_class"`
+	Cpu            types.Int32  `tfsdk:"cpu"`
+	Description    types.String `tfsdk:"description"`
+	Id             types.String `tfsdk:"id"`
+	FlavorId       types.String `tfsdk:"flavor_id"`
+	MaxGb          types.Int32  `tfsdk:"max_gb"`
+	Memory         types.Int32  `tfsdk:"ram"`
+	MinGb          types.Int32  `tfsdk:"min_gb"`
+	NodeType       types.String `tfsdk:"node_type"`
+	StorageClasses types.List   `tfsdk:"storage_classes"`
+}
+
+// NewFlavorDataSource is a helper function to simplify the provider implementation.
+func NewFlavorDataSource() datasource.DataSource {
+	return &flavorDataSource{}
+}
+
+// flavorDataSource is the data source implementation.
+type flavorDataSource struct {
+	client       *v3alpha1api.APIClient
+	providerData core.ProviderData
+}
+
+// Metadata returns the data source type name.
+func (r *flavorDataSource) Metadata(_ context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {
+	resp.TypeName = req.ProviderTypeName + "_postgresflexalpha_flavor"
+}
+
+// Configure adds the provider configured client to the data source.
+func (r *flavorDataSource) Configure(ctx context.Context, req datasource.ConfigureRequest, resp *datasource.ConfigureResponse) {
+	var ok bool
+	r.providerData, ok = conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
+	if !ok {
+		return
+	}
+
+	apiClient := postgresflexUtils.ConfigureClient(ctx, &r.providerData, &resp.Diagnostics)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	r.client = apiClient
+	tflog.Info(ctx, "Postgres Flex instance client configured")
+}
+
+func (r *flavorDataSource) Schema(ctx context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	resp.Schema = schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"project_id": schema.StringAttribute{
+				Required:            true,
+				Description:         "The cpu count of the instance.",
+				MarkdownDescription: "The cpu count of the instance.",
+			},
+			"region": schema.StringAttribute{
+				Required:            true,
+				Description:         "The flavor description.",
+				MarkdownDescription: "The flavor description.",
+			},
+			"cpu": schema.Int32Attribute{
+				Required:            true,
+				Description:         "The cpu count of the instance.",
+				MarkdownDescription: "The cpu count of the instance.",
+			},
+			"ram": schema.Int32Attribute{
+				Required:            true,
+				Description:         "The memory of the instance in Gibibyte.",
+				MarkdownDescription: "The memory of the instance in Gibibyte.",
+			},
+			"storage_class": schema.StringAttribute{
+				Required:            true,
+				Description:         "The memory of the instance in Gibibyte.",
+				MarkdownDescription: "The memory of the instance in Gibibyte.",
+			},
+			"description": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The flavor description.",
+				MarkdownDescription: "The flavor description.",
+			},
+			"id": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The terraform id of the instance flavor.",
+				MarkdownDescription: "The terraform id of the instance flavor.",
+			},
+			"flavor_id": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The flavor id of the instance flavor.",
+				MarkdownDescription: "The flavor id of the instance flavor.",
+			},
+			"max_gb": schema.Int32Attribute{
+				Computed:            true,
+				Description:         "maximum storage which can be ordered for the flavor in Gigabyte.",
+				MarkdownDescription: "maximum storage which can be ordered for the flavor in Gigabyte.",
+			},
+			"min_gb": schema.Int32Attribute{
+				Computed:            true,
+				Description:         "minimum storage which is required to order in Gigabyte.",
+				MarkdownDescription: "minimum storage which is required to order in Gigabyte.",
+			},
+			"node_type": schema.StringAttribute{
+				Required:            true,
+				Description:         "defines the nodeType it can be either single or replica",
+				MarkdownDescription: "defines the nodeType it can be either single or replica",
+			},
+			"storage_classes": schema.ListNestedAttribute{
+				Computed: true,
+				NestedObject: schema.NestedAttributeObject{
+					Attributes: map[string]schema.Attribute{
+						"class": schema.StringAttribute{
+							Computed: true,
+						},
+						"max_io_per_sec": schema.Int32Attribute{
+							Computed: true,
+						},
+						"max_through_in_mb": schema.Int32Attribute{
+							Computed: true,
+						},
+					},
+					CustomType: postgresflexalphaGen.StorageClassesType{
+						ObjectType: types.ObjectType{
+							AttrTypes: postgresflexalphaGen.StorageClassesValue{}.AttributeTypes(ctx),
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func (r *flavorDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) {
+	var model FlavorModel
+	diags := req.Config.Get(ctx, &model)
+	resp.Diagnostics.Append(diags...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	ctx = core.InitProviderContext(ctx)
+
+	projectId := model.ProjectId.ValueString()
+	region := r.providerData.GetRegionWithOverride(model.Region)
+	ctx = tflog.SetField(ctx, "project_id", projectId)
+	ctx = tflog.SetField(ctx, "region", region)
+
+	flavors, err := getAllFlavors(ctx, r.client.DefaultAPI, projectId, region)
+	if err != nil {
+		core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading flavors", fmt.Sprintf("getAllFlavors: %v", err))
+		return
+	}
+
+	var foundFlavors []v3alpha1api.ListFlavors
+	for _, flavor := range flavors {
+		if model.Cpu.ValueInt32() != flavor.Cpu {
+			continue
+		}
+		if model.Memory.ValueInt32() != flavor.Memory {
+			continue
+		}
+		if model.NodeType.ValueString() != flavor.NodeType {
+			continue
+		}
+		for _, sc := range flavor.StorageClasses {
+			if model.StorageClass.ValueString() != sc.Class {
+				continue
+			}
+			foundFlavors = append(foundFlavors, flavor)
+		}
+	}
+	if len(foundFlavors) == 0 {
+		resp.Diagnostics.AddError("get flavor", "could not find requested flavor")
+		return
+	}
+	if len(foundFlavors) > 1 {
+		resp.Diagnostics.AddError("get flavor", "found too many matching flavors")
+		return
+	}
+
+	f := foundFlavors[0]
+	model.Description = types.StringValue(f.Description)
+	model.Id = utils.BuildInternalTerraformId(model.ProjectId.ValueString(), region, f.Id)
+	model.FlavorId = types.StringValue(f.Id)
+	model.MaxGb = types.Int32Value(f.MaxGB)
+	model.MinGb = types.Int32Value(f.MinGB)
+
+	if f.StorageClasses == nil {
+		model.StorageClasses = types.ListNull(postgresflexalphaGen.StorageClassesType{
+			ObjectType: basetypes.ObjectType{
+				AttrTypes: postgresflexalphaGen.StorageClassesValue{}.AttributeTypes(ctx),
+			},
+		})
+	} else {
+		var scList []attr.Value
+		for _, sc := range f.StorageClasses {
+			scList = append(
+				scList,
+				postgresflexalphaGen.NewStorageClassesValueMust(
+					postgresflexalphaGen.StorageClassesValue{}.AttributeTypes(ctx),
+					map[string]attr.Value{
+						"class":             types.StringValue(sc.Class),
+						"max_io_per_sec":    types.Int32Value(sc.MaxIoPerSec),
+						"max_through_in_mb": types.Int32Value(sc.MaxThroughInMb),
+					},
+				),
+			)
+		}
+		storageClassesList := types.ListValueMust(
+			postgresflexalphaGen.StorageClassesType{
+				ObjectType: basetypes.ObjectType{
+					AttrTypes: postgresflexalphaGen.StorageClassesValue{}.AttributeTypes(ctx),
+				},
+			},
+			scList,
+		)
+		model.StorageClasses = storageClassesList
+	}
+
+	// Set refreshed state
+	diags = resp.State.Set(ctx, model)
+	resp.Diagnostics.Append(diags...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	tflog.Info(ctx, "Postgres Flex flavors read")
+}

stackit/internal/services/postgresflexalpha/flavor/functions.go

@@ -0,0 +1,65 @@
+package postgresflexalphaflavor
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
+)
+
+type flavorsClientReader interface {
+	GetFlavorsRequest(
+		ctx context.Context,
+		projectId, region string,
+	) v3alpha1api.ApiGetFlavorsRequestRequest
+}
+
+func getAllFlavors(ctx context.Context, client flavorsClientReader, projectId, region string) (
+	[]v3alpha1api.ListFlavors,
+	error,
+) {
+	getAllFilter := func(_ v3alpha1api.ListFlavors) bool { return true }
+	flavorList, err := getFlavorsByFilter(ctx, client, projectId, region, getAllFilter)
+	if err != nil {
+		return nil, err
+	}
+	return flavorList, nil
+}
+
+// getFlavorsByFilter is a helper function to retrieve flavors using a filtern function.
+// Hint: The API does not have a GetFlavors endpoint, only ListFlavors
+func getFlavorsByFilter(
+	ctx context.Context,
+	client flavorsClientReader,
+	projectId, region string,
+	filter func(db v3alpha1api.ListFlavors) bool,
+) ([]v3alpha1api.ListFlavors, error) {
+	if projectId == "" || region == "" {
+		return nil, fmt.Errorf("listing postgresflex flavors: projectId and region are required")
+	}
+
+	const pageSize = 25
+
+	var result = make([]v3alpha1api.ListFlavors, 0)
+
+	for page := int32(1); ; page++ {
+		res, err := client.GetFlavorsRequest(ctx, projectId, region).
+			Page(page).Size(pageSize).Sort(v3alpha1api.FLAVORSORT_ID_ASC).Execute()
+		if err != nil {
+			return nil, fmt.Errorf("requesting flavors list (page %d): %w", page, err)
+		}
+
+		// If the API returns no flavors, we have reached the end of the list.
+		if len(res.Flavors) == 0 {
+			break
+		}
+
+		for _, flavor := range res.Flavors {
+			if filter(flavor) {
+				result = append(result, flavor)
+			}
+		}
+	}
+
+	return result, nil
+}

stackit/internal/services/postgresflexalpha/flavor/functions_test.go

@@ -0,0 +1,135 @@
+package postgresflexalphaflavor
+
+/*
+import (
+	"context"
+	"testing"
+
+	postgresflex "github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
+)
+
+type mockRequest struct {
+	executeFunc func() (*postgresflex.GetFlavorsResponse, error)
+}
+
+func (m *mockRequest) Page(_ int32) postgresflex.ApiGetFlavorsRequestRequest { return m }
+func (m *mockRequest) Size(_ int32) postgresflex.ApiGetFlavorsRequestRequest { return m }
+func (m *mockRequest) Sort(_ postgresflex.FlavorSort) postgresflex.ApiGetFlavorsRequestRequest {
+	return m
+}
+func (m *mockRequest) Execute() (*postgresflex.GetFlavorsResponse, error) {
+	return m.executeFunc()
+}
+
+type mockFlavorsClient struct {
+	executeRequest func() postgresflex.ApiGetFlavorsRequestRequest
+}
+
+func (m *mockFlavorsClient) GetFlavorsRequest(_ context.Context, _, _ string) postgresflex.ApiGetFlavorsRequestRequest {
+	return m.executeRequest()
+}
+
+var mockResp = func(page int32) (*postgresflex.GetFlavorsResponse, error) {
+	if page == 1 {
+		return &postgresflex.GetFlavorsResponse{
+			Flavors: []postgresflex.ListFlavors{
+				{Id: "flavor-1", Description: "first"},
+				{Id: "flavor-2", Description: "second"},
+			},
+		}, nil
+	}
+	if page == 2 {
+		return &postgresflex.GetFlavorsResponse{
+			Flavors: []postgresflex.ListFlavors{
+				{Id: "flavor-3", Description: "three"},
+			},
+		}, nil
+	}
+
+	return &postgresflex.GetFlavorsResponse{
+		Flavors: []postgresflex.ListFlavors{},
+	}, nil
+}
+
+func TestGetFlavorsByFilter(t *testing.T) {
+	tests := []struct {
+		description string
+		projectId   string
+		region      string
+		mockErr     error
+		filter      func(postgresflex.ListFlavors) bool
+		wantCount   int
+		wantErr     bool
+	}{
+		{
+			description: "Success - Get all flavors (2 pages)",
+			projectId:   "pid", region: "reg",
+			filter:    func(_ postgresflex.ListFlavors) bool { return true },
+			wantCount: 3,
+			wantErr:   false,
+		},
+		{
+			description: "Success - Filter flavors by description",
+			projectId:   "pid", region: "reg",
+			filter:    func(f postgresflex.ListFlavors) bool { return f.Description == "first" },
+			wantCount: 1,
+			wantErr:   false,
+		},
+		{
+			description: "Error - Missing parameters",
+			projectId:   "", region: "reg",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(
+			tt.description, func(t *testing.T) {
+				var currentPage int32
+				client := &mockFlavorsClient{
+					executeRequest: func() postgresflex.ApiGetFlavorsRequestRequest {
+						return mockRequest{
+							executeFunc: func() (*postgresflex.GetFlavorsResponse, error) {
+								currentPage++
+								return mockResp(currentPage)
+							},
+						}
+					},
+				}
+				actual, err := getFlavorsByFilter(context.Background(), client, tt.projectId, tt.region, tt.filter)
+
+				if (err != nil) != tt.wantErr {
+					t.Errorf("getFlavorsByFilter() error = %v, wantErr %v", err, tt.wantErr)
+					return
+				}
+
+				if !tt.wantErr && len(actual) != tt.wantCount {
+					t.Errorf("getFlavorsByFilter() got %d flavors, want %d", len(actual), tt.wantCount)
+				}
+			},
+		)
+	}
+}
+
+func TestGetAllFlavors(t *testing.T) {
+	var currentPage int32
+	client := &mockFlavorsClient{
+		executeRequest: func() postgresflex.ApiGetFlavorsRequestRequest {
+			return mockRequest{
+				executeFunc: func() (*postgresflex.GetFlavorsResponse, error) {
+					currentPage++
+					return mockResp(currentPage)
+				},
+			}
+		},
+	}
+
+	res, err := getAllFlavors(context.Background(), client, "pid", "reg")
+	if err != nil {
+		t.Errorf("getAllFlavors() unexpected error: %v", err)
+	}
+	if len(res) != 3 {
+		t.Errorf("getAllFlavors() expected 3 flavor, got %d", len(res))
+	}
+}
+*/

stackit/internal/services/postgresflexalpha/flavors/datasource.go

@@ -0,0 +1,82 @@
+package postgresflexalpha
+
+import (
+	"context"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource"
+	"github.com/hashicorp/terraform-plugin-log/tflog"
+	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
+
+	"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"
+	postgresflexalphaGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/flavors/datasources_gen"
+	postgresflexUtils "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/utils"
+)
+
+var (
+	_ datasource.DataSource              = &flavorsDataSource{}
+	_ datasource.DataSourceWithConfigure = &flavorsDataSource{}
+)
+
+func NewFlavorsDataSource() datasource.DataSource {
+	return &flavorsDataSource{}
+}
+
+// dataSourceModel maps the data source schema data.
+type dataSourceModel = postgresflexalphaGen.FlavorsModel
+
+type flavorsDataSource struct {
+	client       *v3alpha1api.APIClient
+	providerData core.ProviderData
+}
+
+func (d *flavorsDataSource) Metadata(
+	_ context.Context,
+	req datasource.MetadataRequest,
+	resp *datasource.MetadataResponse,
+) {
+	resp.TypeName = req.ProviderTypeName + "_postgresflexalpha_flavors"
+}
+
+func (d *flavorsDataSource) Schema(ctx context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	resp.Schema = postgresflexalphaGen.FlavorsDataSourceSchema(ctx)
+}
+
+// Configure adds the provider configured client to the data source.
+func (d *flavorsDataSource) Configure(
+	ctx context.Context,
+	req datasource.ConfigureRequest,
+	resp *datasource.ConfigureResponse,
+) {
+	var ok bool
+	d.providerData, ok = conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
+	if !ok {
+		return
+	}
+
+	apiClient := postgresflexUtils.ConfigureClient(ctx, &d.providerData, &resp.Diagnostics)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	d.client = apiClient
+	tflog.Info(ctx, "Postgres Flex version client configured")
+}
+
+func (d *flavorsDataSource) 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)...)
+
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	// Todo: Read API call logic
+
+	// Example data value setting
+	// data.Id = types.StringValue("example-id")
+
+	// Save data into Terraform state
+	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
+}

stackit/internal/services/postgresflexalpha/instance/datasource.go

@@ -0,0 +1,130 @@
+package postgresflexalpha
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
+
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/conversion"
+	postgresflexalpha2 "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/instance/datasources_gen"
+	postgresflexUtils "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/utils"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource"
+	"github.com/hashicorp/terraform-plugin-log/tflog"
+
+	"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"
+)
+
+// Ensure the implementation satisfies the expected interfaces.
+var (
+	_ datasource.DataSource = &instanceDataSource{}
+)
+
+// NewInstanceDataSource is a helper function to simplify the provider implementation.
+func NewInstanceDataSource() datasource.DataSource {
+	return &instanceDataSource{}
+}
+
+// dataSourceModel maps the data source schema data.
+type dataSourceModel struct {
+	postgresflexalpha2.InstanceModel
+	TerraformID types.String `tfsdk:"id"`
+}
+
+// instanceDataSource is the data source implementation.
+type instanceDataSource struct {
+	client       *v3alpha1api.APIClient
+	providerData core.ProviderData
+}
+
+// Metadata returns the data source type name.
+func (r *instanceDataSource) Metadata(
+	_ context.Context,
+	req datasource.MetadataRequest,
+	resp *datasource.MetadataResponse,
+) {
+	resp.TypeName = req.ProviderTypeName + "_postgresflexalpha_instance"
+}
+
+// Configure adds the provider configured client to the data source.
+func (r *instanceDataSource) Configure(
+	ctx context.Context,
+	req datasource.ConfigureRequest,
+	resp *datasource.ConfigureResponse,
+) {
+	var ok bool
+	r.providerData, ok = conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
+	if !ok {
+		return
+	}
+
+	apiClient := postgresflexUtils.ConfigureClient(ctx, &r.providerData, &resp.Diagnostics)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	r.client = apiClient
+	tflog.Info(ctx, "Postgres Flex instance client configured")
+}
+
+// Schema defines the schema for the data source.
+func (r *instanceDataSource) Schema(ctx context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	resp.Schema = postgresflexalpha2.InstanceDataSourceSchema(ctx)
+}
+
+// Read refreshes the Terraform state with the latest data.
+func (r *instanceDataSource) Read(
+	ctx context.Context,
+	req datasource.ReadRequest,
+	resp *datasource.ReadResponse,
+) { // nolint:gocritic // function signature required by Terraform
+	var model dataSourceModel
+	diags := req.Config.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 := r.providerData.GetRegionWithOverride(model.Region)
+	ctx = tflog.SetField(ctx, "project_id", projectId)
+	ctx = tflog.SetField(ctx, "instance_id", instanceId)
+	ctx = tflog.SetField(ctx, "region", region)
+	instanceResp, err := r.client.DefaultAPI.GetInstanceRequest(ctx, projectId, region, instanceId).Execute()
+	if err != nil {
+		utils.LogError(
+			ctx,
+			&resp.Diagnostics,
+			err,
+			"Reading instance",
+			fmt.Sprintf("Instance with ID %q does not exist in project %q.", instanceId, projectId),
+			map[int]string{
+				http.StatusForbidden: fmt.Sprintf("Project with ID %q not found or forbidden access", projectId),
+			},
+		)
+		resp.State.RemoveResource(ctx)
+		return
+	}
+
+	ctx = core.LogResponse(ctx)
+
+	err = mapGetDataInstanceResponseToModel(ctx, &model, instanceResp)
+	if err != nil {
+		core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading instance", fmt.Sprintf("Calling API: %v", err))
+		return
+	}
+
+	// Set refreshed state
+	diags = resp.State.Set(ctx, model)
+	resp.Diagnostics.Append(diags...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	tflog.Info(ctx, "Postgres Flex instance read")
+}

stackit/internal/services/postgresflexalpha/instance/datasource.go.bak

@@ -1,222 +0,0 @@
-package postgresflexa
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-
-	"github.com/stackitcloud/terraform-provider-stackit/pkg/postgresflexalpha"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/conversion"
-	postgresflexUtils "github.com/stackitcloud/terraform-provider-stackit/stackit/internal/services/postgresflexalpha/utils"
-
-	"github.com/hashicorp/terraform-plugin-framework/datasource"
-	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
-	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
-	"github.com/hashicorp/terraform-plugin-log/tflog"
-	"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/datasource/schema"
-	"github.com/hashicorp/terraform-plugin-framework/types"
-	"github.com/stackitcloud/terraform-provider-stackit/pkg/postgresflexalpha/wait"
-)
-
-// Ensure the implementation satisfies the expected interfaces.
-var (
-	_ datasource.DataSource = &instanceDataSource{}
-)
-
-// NewInstanceDataSource is a helper function to simplify the provider implementation.
-func NewInstanceDataSource() datasource.DataSource {
-	return &instanceDataSource{}
-}
-
-// instanceDataSource is the data source implementation.
-type instanceDataSource struct {
-	client       *postgresflexalpha.APIClient
-	providerData core.ProviderData
-}
-
-// Metadata returns the data source type name.
-func (r *instanceDataSource) Metadata(_ context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {
-	resp.TypeName = req.ProviderTypeName + "_postgresflexalpha_instance"
-}
-
-// Configure adds the provider configured client to the data source.
-func (r *instanceDataSource) Configure(ctx context.Context, req datasource.ConfigureRequest, resp *datasource.ConfigureResponse) {
-	var ok bool
-	r.providerData, ok = conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
-	if !ok {
-		return
-	}
-
-	apiClient := postgresflexUtils.ConfigureClient(ctx, &r.providerData, &resp.Diagnostics)
-	if resp.Diagnostics.HasError() {
-		return
-	}
-	r.client = apiClient
-	tflog.Info(ctx, "Postgres Flex instance client configured")
-}
-
-// Schema defines the schema for the data source.
-func (r *instanceDataSource) Schema(_ context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
-	descriptions := map[string]string{
-		"main":        "Postgres Flex instance data source schema. Must have a `region` specified in the provider configuration.",
-		"id":          "Terraform's internal data source. ID. It is structured as \"`project_id`,`region`,`instance_id`\".",
-		"instance_id": "ID of the PostgresFlex instance.",
-		"project_id":  "STACKIT project ID to which the instance is associated.",
-		"name":        "Instance name.",
-		"acl":         "The Access Control List (ACL) for the PostgresFlex instance.",
-		"region":      "The resource region. If not defined, the provider region is used.",
-	}
-
-	resp.Schema = schema.Schema{
-		Description: descriptions["main"],
-		Attributes: map[string]schema.Attribute{
-			"id": schema.StringAttribute{
-				Description: descriptions["id"],
-				Computed:    true,
-			},
-			"instance_id": schema.StringAttribute{
-				Description: descriptions["instance_id"],
-				Required:    true,
-				Validators: []validator.String{
-					validate.UUID(),
-					validate.NoSeparator(),
-				},
-			},
-			"project_id": schema.StringAttribute{
-				Description: descriptions["project_id"],
-				Required:    true,
-				Validators: []validator.String{
-					validate.UUID(),
-					validate.NoSeparator(),
-				},
-			},
-			"name": schema.StringAttribute{
-				Description: descriptions["name"],
-				Computed:    true,
-			},
-			"acl": schema.ListAttribute{
-				Description: descriptions["acl"],
-				ElementType: types.StringType,
-				Computed:    true,
-			},
-			"backup_schedule": schema.StringAttribute{
-				Computed: true,
-			},
-			"flavor": schema.SingleNestedAttribute{
-				Computed: true,
-				Attributes: map[string]schema.Attribute{
-					"id": schema.StringAttribute{
-						Computed: true,
-					},
-					"description": schema.StringAttribute{
-						Computed: true,
-					},
-					"cpu": schema.Int64Attribute{
-						Computed: true,
-					},
-					"ram": schema.Int64Attribute{
-						Computed: true,
-					},
-				},
-			},
-			"replicas": schema.Int64Attribute{
-				Computed: true,
-			},
-			"storage": schema.SingleNestedAttribute{
-				Computed: true,
-				Attributes: map[string]schema.Attribute{
-					"class": schema.StringAttribute{
-						Computed: true,
-					},
-					"size": schema.Int64Attribute{
-						Computed: true,
-					},
-				},
-			},
-			"version": schema.StringAttribute{
-				Computed: true,
-			},
-			"region": schema.StringAttribute{
-				// the region cannot be found, so it has to be passed
-				Optional:    true,
-				Description: descriptions["region"],
-			},
-		},
-	}
-}
-
-// Read refreshes the Terraform state with the latest data.
-func (r *instanceDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) { // nolint:gocritic // function signature required by Terraform
-	var model Model
-	diags := req.Config.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 := r.providerData.GetRegionWithOverride(model.Region)
-	ctx = tflog.SetField(ctx, "project_id", projectId)
-	ctx = tflog.SetField(ctx, "instance_id", instanceId)
-	ctx = tflog.SetField(ctx, "region", region)
-	instanceResp, err := r.client.GetInstanceRequest(ctx, projectId, region, instanceId).Execute()
-	if err != nil {
-		utils.LogError(
-			ctx,
-			&resp.Diagnostics,
-			err,
-			"Reading instance",
-			fmt.Sprintf("Instance with ID %q does not exist in project %q.", instanceId, projectId),
-			map[int]string{
-				http.StatusForbidden: fmt.Sprintf("Project with ID %q not found or forbidden access", projectId),
-			},
-		)
-		resp.State.RemoveResource(ctx)
-		return
-	}
-
-	ctx = core.LogResponse(ctx)
-
-	if instanceResp != nil && instanceResp.Status != nil && *instanceResp.Status == wait.InstanceStateDeleted {
-		resp.State.RemoveResource(ctx)
-		core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading instance", "Instance was deleted successfully")
-		return
-	}
-
-	var flavor = &flavorModel{}
-	if !(model.Flavor.IsNull() || model.Flavor.IsUnknown()) {
-		diags = model.Flavor.As(ctx, flavor, basetypes.ObjectAsOptions{})
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-	var storage = &storageModel{}
-	if !(model.Storage.IsNull() || model.Storage.IsUnknown()) {
-		diags = model.Storage.As(ctx, storage, basetypes.ObjectAsOptions{})
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-
-	err = mapFields(ctx, instanceResp, &model, flavor, storage, region)
-	if err != nil {
-		core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading instance", 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, "Postgres Flex instance read")
-}

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

@@ -0,0 +1,241 @@
+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())
+	if m.Id.IsNull() || m.Id.IsUnknown() {
+		m.Id = utils.BuildInternalTerraformId(
+			m.ProjectId.ValueString(),
+			m.Region.ValueString(),
+			m.InstanceId.ValueString(),
+		)
+	}
+	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 = 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),
+	}
+}

stackit/internal/services/postgresflexalpha/instance/functions_test.go

@@ -0,0 +1,191 @@
+package postgresflexalpha
+
+import (
+	"context"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
+	postgresflex "github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
+
+	postgresflexalpharesource "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/instance/resources_gen"
+	utils2 "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/utils"
+)
+
+func Test_handleConnectionInfo(t *testing.T) {
+	type args struct {
+		ctx      context.Context
+		m        *dataSourceModel
+		hostName string
+		port     int32
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		{
+			name: "empty connection info",
+			args: args{
+				ctx:      context.TODO(),
+				m:        &dataSourceModel{},
+				hostName: "",
+				port:     0,
+			},
+		},
+		{
+			name: "empty connection info host",
+			args: args{
+				ctx:      context.TODO(),
+				m:        &dataSourceModel{},
+				hostName: "",
+				port:     1234,
+			},
+		},
+		{
+			name: "empty connection info port",
+			args: args{
+				ctx:      context.TODO(),
+				m:        &dataSourceModel{},
+				hostName: "hostname",
+				port:     0,
+			},
+		},
+		{
+			name: "valid connection info",
+			args: args{
+				ctx:      context.TODO(),
+				m:        &dataSourceModel{},
+				hostName: "host",
+				port:     1000,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			resp := &postgresflex.GetInstanceResponse{
+				ConnectionInfo: postgresflex.InstanceConnectionInfo{
+					Write: postgresflex.InstanceConnectionInfoWrite{
+						Host: tt.args.hostName,
+						Port: int32(tt.args.port),
+					},
+				},
+			}
+
+			handleConnectionInfo(tt.args.ctx, tt.args.m, resp)
+
+			if tt.args.hostName == "" || tt.args.port == 0 {
+				if !tt.args.m.ConnectionInfo.IsNull() {
+					t.Errorf("expected connection info to be null")
+				}
+			}
+
+			if tt.args.hostName != "" && tt.args.port != 0 {
+				res := tt.args.m.ConnectionInfo.Write.Attributes()
+				gotHost := ""
+				if r, ok := res["host"]; ok {
+					gotHost = utils2.RemoveQuotes(r.String())
+				}
+				if gotHost != tt.args.hostName {
+					t.Errorf("host value incorrect: want: %s - got: %s", tt.args.hostName, gotHost)
+				}
+
+				gotPort, ok := res["port"]
+				if !ok {
+					t.Errorf("could not find a value for port in connection_info.write")
+				}
+				if !gotPort.Equal(types.Int64Value(int64(tt.args.port))) {
+					t.Errorf("port value incorrect: want: %d - got: %s", tt.args.port, gotPort.String())
+				}
+			}
+		})
+	}
+}
+
+func Test_handleEncryption(t *testing.T) {
+	t.Skipf("please implement")
+	type args struct {
+		m    *dataSourceModel
+		resp *postgresflex.GetInstanceResponse
+	}
+	tests := []struct {
+		name string
+		args args
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			handleEncryption(tt.args.m, tt.args.resp)
+			t.Logf("need to implement more")
+		})
+	}
+}
+
+func Test_handleNetwork(t *testing.T) {
+	t.Skipf("please implement")
+	type args struct {
+		ctx  context.Context
+		m    *dataSourceModel
+		resp *postgresflex.GetInstanceResponse
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := handleNetwork(tt.args.ctx, tt.args.m, tt.args.resp); (err != nil) != tt.wantErr {
+				t.Errorf("handleNetwork() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func Test_mapGetDataInstanceResponseToModel(t *testing.T) {
+	t.Skipf("please implement")
+	type args struct {
+		ctx  context.Context
+		m    *dataSourceModel
+		resp *postgresflex.GetInstanceResponse
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := mapGetDataInstanceResponseToModel(tt.args.ctx, tt.args.m, tt.args.resp); (err != nil) != tt.wantErr {
+				t.Errorf("mapGetDataInstanceResponseToModel() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func Test_mapGetInstanceResponseToModel(t *testing.T) {
+	t.Skipf("please implement")
+	type args struct {
+		ctx  context.Context
+		m    *postgresflexalpharesource.InstanceModel
+		resp *postgresflex.GetInstanceResponse
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := mapGetInstanceResponseToModel(tt.args.ctx, tt.args.m, tt.args.resp); (err != nil) != tt.wantErr {
+				t.Errorf("mapGetInstanceResponseToModel() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

stackit/internal/services/postgresflexalpha/instance/planModifiers.yaml

@@ -0,0 +1,120 @@
+fields:
+  - name: 'backup_schedule'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'connection_info.host'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'connection_info.port'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'encryption.kek_key_id'
+    validators:
+      - validate.NoSeparator
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'encryption.kek_key_ring_id'
+    validators:
+      - validate.NoSeparator
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'encryption.kek_key_version'
+    validators:
+      - validate.NoSeparator
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'encryption.service_account'
+    validators:
+      - validate.NoSeparator
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'flavor_id'
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'id'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'instance_id'
+    validators:
+      - validate.NoSeparator
+      - validate.UUID
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'is_deletable'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'name'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'network.access_scope'
+    validators:
+      - validate.NoSeparator
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'network.acl'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'network.instance_address'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'network.router_address'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'project_id'
+    validators:
+      - validate.NoSeparator
+      - validate.UUID
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'region'
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'replicas'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'retention_days'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'status'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'storage'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'storage.performance_class'
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'storage.size'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'version'
+    modifiers:
+      - 'UseStateForUnknown'

stackit/internal/services/postgresflexalpha/instance/resource_test.go

@@ -1,768 +0,0 @@
-// Copyright (c) STACKIT
-
-package postgresflex
-
-import (
-	"context"
-	"fmt"
-	"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"
-	postgresflex "github.com/stackitcloud/terraform-provider-stackit/pkg/postgresflexalpha"
-)
-
-type postgresFlexClientMocked struct {
-	returnError    bool
-	getFlavorsResp *postgresflex.GetFlavorsResponse
-}
-
-func (c *postgresFlexClientMocked) ListFlavorsExecute(_ context.Context, _, _ string) (*postgresflex.GetFlavorsResponse, error) {
-	if c.returnError {
-		return nil, fmt.Errorf("get flavors failed")
-	}
-
-	return c.getFlavorsResp, nil
-}
-
-func TestMapFields(t *testing.T) {
-	const testRegion = "region"
-	tests := []struct {
-		description string
-		state       Model
-		input       *postgresflex.GetInstanceResponse
-		flavor      *flavorModel
-		storage     *storageModel
-		region      string
-		expected    Model
-		isValid     bool
-	}{
-		{
-			"default_values",
-			Model{
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-			},
-			&postgresflex.GetInstanceResponse{},
-			&flavorModel{},
-			&storageModel{},
-			testRegion,
-			Model{
-				Id:             types.StringValue("pid,region,iid"),
-				InstanceId:     types.StringValue("iid"),
-				ProjectId:      types.StringValue("pid"),
-				Name:           types.StringNull(),
-				ACL:            types.ListNull(types.StringType),
-				BackupSchedule: types.StringNull(),
-				Flavor: types.ObjectValueMust(flavorTypes, map[string]attr.Value{
-					"id":          types.StringNull(),
-					"description": types.StringNull(),
-					"cpu":         types.Int64Null(),
-					"ram":         types.Int64Null(),
-				}),
-				Replicas: types.Int64Null(),
-				Storage: types.ObjectValueMust(storageTypes, map[string]attr.Value{
-					"class": types.StringNull(),
-					"size":  types.Int64Null(),
-				}),
-				Version: types.StringNull(),
-				Region:  types.StringValue(testRegion),
-			},
-			true,
-		},
-		{
-			"simple_values",
-			Model{
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-			},
-			&postgresflex.GetInstanceResponse{
-				Acl: &[]string{
-					"ip1",
-					"ip2",
-					"",
-				},
-				BackupSchedule: utils.Ptr("schedule"),
-				//Flavor: &postgresflex.Flavor{
-				//	Cpu:         utils.Ptr(int64(12)),
-				//	Description: utils.Ptr("description"),
-				//	Id:          utils.Ptr("flavor_id"),
-				//	Memory:      utils.Ptr(int64(34)),
-				//},
-				Id:       utils.Ptr("iid"),
-				Name:     utils.Ptr("name"),
-				Replicas: postgresflex.GetInstanceResponseGetReplicasAttributeType(utils.Ptr(int32(56))),
-				Status:   postgresflex.GetInstanceResponseGetStatusAttributeType(utils.Ptr("status")),
-				Storage: &postgresflex.Storage{
-					PerformanceClass: utils.Ptr("class"),
-					Size:             utils.Ptr(int64(78)),
-				},
-				Version: utils.Ptr("version"),
-			},
-			&flavorModel{},
-			&storageModel{},
-			testRegion,
-			Model{
-				Id:         types.StringValue("pid,region,iid"),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Name:       types.StringValue("name"),
-				ACL: types.ListValueMust(types.StringType, []attr.Value{
-					types.StringValue("ip1"),
-					types.StringValue("ip2"),
-					types.StringValue(""),
-				}),
-				BackupSchedule: types.StringValue("schedule"),
-				Flavor: types.ObjectValueMust(flavorTypes, map[string]attr.Value{
-					"id":          types.StringValue("flavor_id"),
-					"description": types.StringValue("description"),
-					"cpu":         types.Int64Value(12),
-					"ram":         types.Int64Value(34),
-				}),
-				Replicas: types.Int64Value(56),
-				Storage: types.ObjectValueMust(storageTypes, map[string]attr.Value{
-					"class": types.StringValue("class"),
-					"size":  types.Int64Value(78),
-				}),
-				Version: types.StringValue("version"),
-				Region:  types.StringValue(testRegion),
-			},
-			true,
-		},
-		{
-			"simple_values_no_flavor_and_storage",
-			Model{
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-			},
-			&postgresflex.GetInstanceResponse{
-				Acl: &[]string{
-					"ip1",
-					"ip2",
-					"",
-				},
-				BackupSchedule: utils.Ptr("schedule"),
-				FlavorId:       nil,
-				Id:             utils.Ptr("iid"),
-				Name:           utils.Ptr("name"),
-				Replicas:       postgresflex.GetInstanceResponseGetReplicasAttributeType(utils.Ptr(int32(56))),
-				Status:         postgresflex.GetInstanceResponseGetStatusAttributeType(utils.Ptr("status")),
-				Storage:        nil,
-				Version:        utils.Ptr("version"),
-			},
-			&flavorModel{
-				CPU: types.Int64Value(12),
-				RAM: types.Int64Value(34),
-			},
-			&storageModel{
-				Class: types.StringValue("class"),
-				Size:  types.Int64Value(78),
-			},
-			testRegion,
-			Model{
-				Id:         types.StringValue("pid,region,iid"),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Name:       types.StringValue("name"),
-				ACL: types.ListValueMust(types.StringType, []attr.Value{
-					types.StringValue("ip1"),
-					types.StringValue("ip2"),
-					types.StringValue(""),
-				}),
-				BackupSchedule: types.StringValue("schedule"),
-				Flavor: types.ObjectValueMust(flavorTypes, map[string]attr.Value{
-					"id":          types.StringNull(),
-					"description": types.StringNull(),
-					"cpu":         types.Int64Value(12),
-					"ram":         types.Int64Value(34),
-				}),
-				Replicas: types.Int64Value(56),
-				Storage: types.ObjectValueMust(storageTypes, map[string]attr.Value{
-					"class": types.StringValue("class"),
-					"size":  types.Int64Value(78),
-				}),
-				Version: types.StringValue("version"),
-				Region:  types.StringValue(testRegion),
-			},
-			true,
-		},
-		{
-			"acl_unordered",
-			Model{
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				ACL: types.ListValueMust(types.StringType, []attr.Value{
-					types.StringValue("ip2"),
-					types.StringValue(""),
-					types.StringValue("ip1"),
-				}),
-			},
-			&postgresflex.GetInstanceResponse{
-				Acl: &[]string{
-					"",
-					"ip1",
-					"ip2",
-				},
-				BackupSchedule: utils.Ptr("schedule"),
-				FlavorId:       nil,
-				Id:             utils.Ptr("iid"),
-				Name:           utils.Ptr("name"),
-				Replicas:       postgresflex.GetInstanceResponseGetReplicasAttributeType(utils.Ptr(int32(56))),
-				Status:         postgresflex.GetInstanceResponseGetStatusAttributeType(utils.Ptr("status")),
-				Storage:        nil,
-				Version:        utils.Ptr("version"),
-			},
-			&flavorModel{
-				CPU: types.Int64Value(12),
-				RAM: types.Int64Value(34),
-			},
-			&storageModel{
-				Class: types.StringValue("class"),
-				Size:  types.Int64Value(78),
-			},
-			testRegion,
-			Model{
-				Id:         types.StringValue("pid,region,iid"),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Name:       types.StringValue("name"),
-				ACL: types.ListValueMust(types.StringType, []attr.Value{
-					types.StringValue("ip2"),
-					types.StringValue(""),
-					types.StringValue("ip1"),
-				}),
-				BackupSchedule: types.StringValue("schedule"),
-				Flavor: types.ObjectValueMust(flavorTypes, map[string]attr.Value{
-					"id":          types.StringNull(),
-					"description": types.StringNull(),
-					"cpu":         types.Int64Value(12),
-					"ram":         types.Int64Value(34),
-				}),
-				Replicas: types.Int64Value(56),
-				Storage: types.ObjectValueMust(storageTypes, map[string]attr.Value{
-					"class": types.StringValue("class"),
-					"size":  types.Int64Value(78),
-				}),
-				Version: types.StringValue("version"),
-				Region:  types.StringValue(testRegion),
-			},
-			true,
-		},
-		{
-			"nil_response",
-			Model{
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-			},
-			nil,
-			&flavorModel{},
-			&storageModel{},
-			testRegion,
-			Model{},
-			false,
-		},
-		{
-			"no_resource_id",
-			Model{
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-			},
-			&postgresflex.GetInstanceResponse{},
-			&flavorModel{},
-			&storageModel{},
-			testRegion,
-			Model{},
-			false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.description, func(t *testing.T) {
-			err := mapFields(context.Background(), tt.input, &tt.state, tt.flavor, tt.storage, 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(tt.state, tt.expected)
-				if diff != "" {
-					t.Fatalf("Data does not match: %s", diff)
-				}
-			}
-		})
-	}
-}
-
-func TestToCreatePayload(t *testing.T) {
-	tests := []struct {
-		description     string
-		input           *Model
-		inputAcl        []string
-		inputFlavor     *flavorModel
-		inputStorage    *storageModel
-		inputEncryption *encryptionModel
-		inputNetwork    *networkModel
-		expected        *postgresflex.CreateInstanceRequestPayload
-		isValid         bool
-	}{
-		{
-			"default_values",
-			&Model{},
-			[]string{},
-			&flavorModel{},
-			&storageModel{},
-			&encryptionModel{},
-			&networkModel{},
-			&postgresflex.CreateInstanceRequestPayload{
-				Acl:     &[]string{},
-				Storage: postgresflex.CreateInstanceRequestPayloadGetStorageAttributeType(&postgresflex.Storage{}),
-			},
-			true,
-		},
-		{
-			"simple_values",
-			&Model{
-				BackupSchedule: types.StringValue("schedule"),
-				Name:           types.StringValue("name"),
-				Replicas:       types.Int64Value(12),
-				Version:        types.StringValue("version"),
-			},
-			[]string{
-				"ip_1",
-				"ip_2",
-			},
-			&flavorModel{
-				Id: types.StringValue("flavor_id"),
-			},
-			&storageModel{
-				Class: types.StringValue("class"),
-				Size:  types.Int64Value(34),
-			},
-			&encryptionModel{},
-			&networkModel{},
-			&postgresflex.CreateInstanceRequestPayload{
-				Acl: &[]string{
-					"ip_1",
-					"ip_2",
-				},
-				BackupSchedule: utils.Ptr("schedule"),
-				FlavorId:       utils.Ptr("flavor_id"),
-				Name:           utils.Ptr("name"),
-				Replicas:       postgresflex.CreateInstanceRequestPayloadGetReplicasAttributeType(utils.Ptr(int32(56))),
-				Storage: postgresflex.CreateInstanceRequestPayloadGetStorageAttributeType(&postgresflex.Storage{
-					PerformanceClass: utils.Ptr("class"),
-					Size:             utils.Ptr(int64(34)),
-				}),
-				Version: utils.Ptr("version"),
-			},
-			true,
-		},
-		{
-			"null_fields_and_int_conversions",
-			&Model{
-				BackupSchedule: types.StringNull(),
-				Name:           types.StringNull(),
-				Replicas:       types.Int64Value(2123456789),
-				Version:        types.StringNull(),
-			},
-			[]string{
-				"",
-			},
-			&flavorModel{
-				Id: types.StringNull(),
-			},
-			&storageModel{
-				Class: types.StringNull(),
-				Size:  types.Int64Null(),
-			},
-			&encryptionModel{},
-			&networkModel{},
-			&postgresflex.CreateInstanceRequestPayload{
-				Acl: &[]string{
-					"",
-				},
-				BackupSchedule: nil,
-				FlavorId:       nil,
-				Name:           nil,
-				Replicas:       postgresflex.CreateInstanceRequestPayloadGetReplicasAttributeType(utils.Ptr(int32(2123456789))),
-				Storage: postgresflex.CreateInstanceRequestPayloadGetStorageAttributeType(&postgresflex.Storage{
-					PerformanceClass: nil,
-					Size:             nil,
-				}),
-				Version: nil,
-			},
-			true,
-		},
-		{
-			"nil_model",
-			nil,
-			[]string{},
-			&flavorModel{},
-			&storageModel{},
-			&encryptionModel{},
-			&networkModel{},
-			nil,
-			false,
-		},
-		{
-			"nil_acl",
-			&Model{},
-			nil,
-			&flavorModel{},
-			&storageModel{},
-			&encryptionModel{},
-			&networkModel{},
-			nil,
-			false,
-		},
-		{
-			"nil_flavor",
-			&Model{},
-			[]string{},
-			nil,
-			&storageModel{},
-			&encryptionModel{},
-			&networkModel{},
-			nil,
-			false,
-		},
-		{
-			"nil_storage",
-			&Model{},
-			[]string{},
-			&flavorModel{},
-			nil,
-			&encryptionModel{},
-			&networkModel{},
-			nil,
-			false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.description, func(t *testing.T) {
-			output, err := toCreatePayload(tt.input, tt.inputAcl, tt.inputFlavor, tt.inputStorage, tt.inputEncryption, tt.inputNetwork)
-			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)
-				}
-			}
-		})
-	}
-}
-
-//func TestToUpdatePayload(t *testing.T) {
-//	tests := []struct {
-//		description  string
-//		input        *Model
-//		inputAcl     []string
-//		inputFlavor  *flavorModel
-//		inputStorage *storageModel
-//		expected     *postgresflex.PartialUpdateInstancePayload
-//		isValid      bool
-//	}{
-//		{
-//			"default_values",
-//			&Model{},
-//			[]string{},
-//			&flavorModel{},
-//			&storageModel{},
-//			&postgresflex.PartialUpdateInstancePayload{
-//				Acl: &postgresflex.ACL{
-//					Items: &[]string{},
-//				},
-//				Storage: &postgresflex.Storage{},
-//			},
-//			true,
-//		},
-//		{
-//			"simple_values",
-//			&Model{
-//				BackupSchedule: types.StringValue("schedule"),
-//				Name:           types.StringValue("name"),
-//				Replicas:       types.Int64Value(12),
-//				Version:        types.StringValue("version"),
-//			},
-//			[]string{
-//				"ip_1",
-//				"ip_2",
-//			},
-//			&flavorModel{
-//				Id: types.StringValue("flavor_id"),
-//			},
-//			&storageModel{
-//				Class: types.StringValue("class"),
-//				Size:  types.Int64Value(34),
-//			},
-//			&postgresflex.PartialUpdateInstancePayload{
-//				Acl: &postgresflex.ACL{
-//					Items: &[]string{
-//						"ip_1",
-//						"ip_2",
-//					},
-//				},
-//				BackupSchedule: utils.Ptr("schedule"),
-//				FlavorId:       utils.Ptr("flavor_id"),
-//				Name:           utils.Ptr("name"),
-//				Replicas:       utils.Ptr(int64(12)),
-//				Storage: &postgresflex.Storage{
-//					Class: utils.Ptr("class"),
-//					Size:  utils.Ptr(int64(34)),
-//				},
-//				Version: utils.Ptr("version"),
-//			},
-//			true,
-//		},
-//		{
-//			"null_fields_and_int_conversions",
-//			&Model{
-//				BackupSchedule: types.StringNull(),
-//				Name:           types.StringNull(),
-//				Replicas:       types.Int64Value(2123456789),
-//				Version:        types.StringNull(),
-//			},
-//			[]string{
-//				"",
-//			},
-//			&flavorModel{
-//				Id: types.StringNull(),
-//			},
-//			&storageModel{
-//				Class: types.StringNull(),
-//				Size:  types.Int64Null(),
-//			},
-//			&postgresflex.PartialUpdateInstancePayload{
-//				Acl: &postgresflex.ACL{
-//					Items: &[]string{
-//						"",
-//					},
-//				},
-//				BackupSchedule: nil,
-//				FlavorId:       nil,
-//				Name:           nil,
-//				Replicas:       utils.Ptr(int64(2123456789)),
-//				Storage: &postgresflex.Storage{
-//					Class: nil,
-//					Size:  nil,
-//				},
-//				Version: nil,
-//			},
-//			true,
-//		},
-//		{
-//			"nil_model",
-//			nil,
-//			[]string{},
-//			&flavorModel{},
-//			&storageModel{},
-//			nil,
-//			false,
-//		},
-//		{
-//			"nil_acl",
-//			&Model{},
-//			nil,
-//			&flavorModel{},
-//			&storageModel{},
-//			nil,
-//			false,
-//		},
-//		{
-//			"nil_flavor",
-//			&Model{},
-//			[]string{},
-//			nil,
-//			&storageModel{},
-//			nil,
-//			false,
-//		},
-//		{
-//			"nil_storage",
-//			&Model{},
-//			[]string{},
-//			&flavorModel{},
-//			nil,
-//			nil,
-//			false,
-//		},
-//	}
-//	for _, tt := range tests {
-//		t.Run(tt.description, func(t *testing.T) {
-//			output, err := toUpdatePayload(tt.input, tt.inputAcl, tt.inputFlavor, tt.inputStorage)
-//			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)
-//				}
-//			}
-//		})
-//	}
-//}
-//
-//func TestLoadFlavorId(t *testing.T) {
-//	tests := []struct {
-//		description     string
-//		inputFlavor     *flavorModel
-//		mockedResp      *postgresflex.ListFlavorsResponse
-//		expected        *flavorModel
-//		getFlavorsFails bool
-//		isValid         bool
-//	}{
-//		{
-//			"ok_flavor",
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			&postgresflex.ListFlavorsResponse{
-//				Flavors: &[]postgresflex.Flavor{
-//					{
-//						Id:          utils.Ptr("fid-1"),
-//						Cpu:         utils.Ptr(int64(2)),
-//						Description: utils.Ptr("description"),
-//						Memory:      utils.Ptr(int64(8)),
-//					},
-//				},
-//			},
-//			&flavorModel{
-//				Id:          types.StringValue("fid-1"),
-//				Description: types.StringValue("description"),
-//				CPU:         types.Int64Value(2),
-//				RAM:         types.Int64Value(8),
-//			},
-//			false,
-//			true,
-//		},
-//		{
-//			"ok_flavor_2",
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			&postgresflex.ListFlavorsResponse{
-//				Flavors: &[]postgresflex.Flavor{
-//					{
-//						Id:          utils.Ptr("fid-1"),
-//						Cpu:         utils.Ptr(int64(2)),
-//						Description: utils.Ptr("description"),
-//						Memory:      utils.Ptr(int64(8)),
-//					},
-//					{
-//						Id:          utils.Ptr("fid-2"),
-//						Cpu:         utils.Ptr(int64(1)),
-//						Description: utils.Ptr("description"),
-//						Memory:      utils.Ptr(int64(4)),
-//					},
-//				},
-//			},
-//			&flavorModel{
-//				Id:          types.StringValue("fid-1"),
-//				Description: types.StringValue("description"),
-//				CPU:         types.Int64Value(2),
-//				RAM:         types.Int64Value(8),
-//			},
-//			false,
-//			true,
-//		},
-//		{
-//			"no_matching_flavor",
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			&postgresflex.ListFlavorsResponse{
-//				Flavors: &[]postgresflex.Flavor{
-//					{
-//						Id:          utils.Ptr("fid-1"),
-//						Cpu:         utils.Ptr(int64(1)),
-//						Description: utils.Ptr("description"),
-//						Memory:      utils.Ptr(int64(8)),
-//					},
-//					{
-//						Id:          utils.Ptr("fid-2"),
-//						Cpu:         utils.Ptr(int64(1)),
-//						Description: utils.Ptr("description"),
-//						Memory:      utils.Ptr(int64(4)),
-//					},
-//				},
-//			},
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			false,
-//			false,
-//		},
-//		{
-//			"nil_response",
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			&postgresflex.ListFlavorsResponse{},
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			false,
-//			false,
-//		},
-//		{
-//			"error_response",
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			&postgresflex.ListFlavorsResponse{},
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			true,
-//			false,
-//		},
-//	}
-//	for _, tt := range tests {
-//		t.Run(tt.description, func(t *testing.T) {
-//			client := &postgresFlexClientMocked{
-//				returnError:    tt.getFlavorsFails,
-//				getFlavorsResp: tt.mockedResp,
-//			}
-//			model := &Model{
-//				ProjectId: types.StringValue("pid"),
-//			}
-//			flavorModel := &flavorModel{
-//				CPU: tt.inputFlavor.CPU,
-//				RAM: tt.inputFlavor.RAM,
-//			}
-//			err := loadFlavorId(context.Background(), client, model, flavorModel)
-//			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(flavorModel, tt.expected)
-//				if diff != "" {
-//					t.Fatalf("Data does not match: %s", diff)
-//				}
-//			}
-//		})
-//	}
-//}

stackit/internal/services/postgresflexalpha/instance/use_state_for_unknown_if_flavor_unchanged_modifier.go

@@ -1,87 +0,0 @@
-// Copyright (c) STACKIT
-
-package postgresflex
-
-import (
-	"context"
-
-	"github.com/hashicorp/terraform-plugin-framework/resource"
-	"github.com/hashicorp/terraform-plugin-framework/resource/schema/planmodifier"
-	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
-)
-
-type useStateForUnknownIfFlavorUnchangedModifier struct {
-	Req resource.SchemaRequest
-}
-
-// UseStateForUnknownIfFlavorUnchanged returns a plan modifier similar to UseStateForUnknown
-// if the RAM and CPU values are not changed in the plan. Otherwise, the plan modifier does nothing.
-func UseStateForUnknownIfFlavorUnchanged(req resource.SchemaRequest) planmodifier.String {
-	return useStateForUnknownIfFlavorUnchangedModifier{
-		Req: req,
-	}
-}
-
-func (m useStateForUnknownIfFlavorUnchangedModifier) Description(context.Context) string {
-	return "UseStateForUnknownIfFlavorUnchanged returns a plan modifier similar to UseStateForUnknown if the RAM and CPU values are not changed in the plan. Otherwise, the plan modifier does nothing."
-}
-
-func (m useStateForUnknownIfFlavorUnchangedModifier) MarkdownDescription(ctx context.Context) string {
-	return m.Description(ctx)
-}
-
-func (m useStateForUnknownIfFlavorUnchangedModifier) PlanModifyString(ctx context.Context, req planmodifier.StringRequest, resp *planmodifier.StringResponse) { // nolint:gocritic // function signature required by Terraform
-	// Do nothing if there is no state value.
-	if req.StateValue.IsNull() {
-		return
-	}
-
-	// Do nothing if there is a known planned value.
-	if !req.PlanValue.IsUnknown() {
-		return
-	}
-
-	// Do nothing if there is an unknown configuration value, otherwise interpolation gets messed up.
-	if req.ConfigValue.IsUnknown() {
-		return
-	}
-
-	// The above checks are taken from the UseStateForUnknown plan modifier implementation
-	// (https://github.com/hashicorp/terraform-plugin-framework/blob/main/resource/schema/stringplanmodifier/use_state_for_unknown.go#L38)
-
-	var stateModel Model
-	diags := req.State.Get(ctx, &stateModel)
-	resp.Diagnostics.Append(diags...)
-	if resp.Diagnostics.HasError() {
-		return
-	}
-
-	var stateFlavor = &flavorModel{}
-	if !(stateModel.Flavor.IsNull() || stateModel.Flavor.IsUnknown()) {
-		diags = stateModel.Flavor.As(ctx, stateFlavor, basetypes.ObjectAsOptions{})
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-
-	var planModel Model
-	diags = req.Plan.Get(ctx, &planModel)
-	resp.Diagnostics.Append(diags...)
-	if resp.Diagnostics.HasError() {
-		return
-	}
-
-	var planFlavor = &flavorModel{}
-	if !(planModel.Flavor.IsNull() || planModel.Flavor.IsUnknown()) {
-		diags = planModel.Flavor.As(ctx, planFlavor, basetypes.ObjectAsOptions{})
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-
-	if planFlavor.CPU == stateFlavor.CPU && planFlavor.RAM == stateFlavor.RAM {
-		resp.PlanValue = req.StateValue
-	}
-}

stackit/internal/services/postgresflexalpha/role/datasources_gen/roles_data_source_gen.go

@@ -0,0 +1,52 @@
+// Code generated by terraform-plugin-framework-generator DO NOT EDIT.
+
+package postgresflexalpha
+
+import (
+	"context"
+	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
+	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+)
+
+func RolesDataSourceSchema(ctx context.Context) schema.Schema {
+	return schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"instance_id": schema.StringAttribute{
+				Required:            true,
+				Description:         "The ID of the instance.",
+				MarkdownDescription: "The ID of the instance.",
+			},
+			"project_id": schema.StringAttribute{
+				Required:            true,
+				Description:         "The STACKIT project ID.",
+				MarkdownDescription: "The STACKIT project ID.",
+			},
+			"region": schema.StringAttribute{
+				Required:            true,
+				Description:         "The region which should be addressed",
+				MarkdownDescription: "The region which should be addressed",
+				Validators: []validator.String{
+					stringvalidator.OneOf(
+						"eu01",
+					),
+				},
+			},
+			"roles": schema.ListAttribute{
+				ElementType:         types.StringType,
+				Computed:            true,
+				Description:         "List of all role names available in the instance",
+				MarkdownDescription: "List of all role names available in the instance",
+			},
+		},
+	}
+}
+
+type RolesModel struct {
+	InstanceId types.String `tfsdk:"instance_id"`
+	ProjectId  types.String `tfsdk:"project_id"`
+	Region     types.String `tfsdk:"region"`
+	Roles      types.List   `tfsdk:"roles"`
+}

stackit/internal/services/postgresflexalpha/testdata/instance_template.gompl

@@ -0,0 +1,54 @@
+provider "stackitprivatepreview" {
+    default_region = "{{ .Region }}"
+    service_account_key_path = "{{ .ServiceAccountFilePath }}"
+}
+
+resource "stackitprivatepreview_postgresflexalpha_instance" "{{ .TfName }}" {
+  project_id      = "{{ .ProjectID }}"
+  name            = "{{ .Name }}"
+  backup_schedule = "{{ .BackupSchedule }}"
+  retention_days  = {{ .RetentionDays }}
+  flavor_id       = "{{ .FlavorID }}"
+  replicas        = {{ .Replicas }}
+  storage = {
+    performance_class = "{{ .PerformanceClass }}"
+    size              = {{ .Size }}
+  }
+{{ if .UseEncryption }}
+  encryption = {
+    kek_key_id      = "{{ .KekKeyID }}"
+    kek_key_ring_id = "{{ .KekKeyRingID }}"
+    kek_key_version = {{ .KekKeyVersion }}
+    service_account = "{{ .KekServiceAccount }}"
+  }
+{{ end }}
+  network = {
+    acl          = ["{{ .ACLString }}"]
+    access_scope = "{{ .AccessScope }}"
+  }
+  version = {{ .Version }}
+}
+
+{{ if .Users }}
+{{ $tfName := .TfName }}
+{{ range $user := .Users }}
+resource "stackitprivatepreview_postgresflexalpha_user" "{{ $user.Name }}" {
+  project_id  = "{{ $user.ProjectID }}"
+  instance_id = stackitprivatepreview_postgresflexalpha_instance.{{ $tfName }}.instance_id
+  name    = "{{ $user.Name }}"
+  roles       = [{{ range $i, $v := $user.Roles }}{{if $i}},{{end}}"{{$v}}"{{end}}]
+}
+{{ end }}
+{{ end }}
+
+{{ if .Databases }}
+{{ $tfName := .TfName }}
+{{ range $db := .Databases }}
+resource "stackitprivatepreview_postgresflexalpha_database" "{{ $db.Name }}" {
+  project_id  = "{{ $db.ProjectID }}"
+  instance_id = stackitprivatepreview_postgresflexalpha_instance.{{ $tfName }}.instance_id
+  name        = "{{ $db.Name }}"
+  owner       = stackitprivatepreview_postgresflexalpha_user.{{ $db.Owner }}.name
+}
+{{ end }}
+{{ end }}

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

@@ -1,26 +1,25 @@
-// Copyright (c) STACKIT
-
-package postgresflexa
+package postgresflexalpha
 
 import (
 	"context"
 	"fmt"
+	"math"
 	"net/http"
 
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/conversion"
-	postgresflexUtils "github.com/stackitcloud/terraform-provider-stackit/stackit/internal/services/postgresflex/utils"
-
-	"github.com/hashicorp/terraform-plugin-framework/attr"
-	"github.com/hashicorp/terraform-plugin-framework/datasource"
-	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
-	"github.com/hashicorp/terraform-plugin-log/tflog"
-	"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/datasource/schema"
+	"github.com/hashicorp/terraform-plugin-framework/diag"
+	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
+
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/conversion"
+	postgresflexalpha "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/user/datasources_gen"
+	postgresflexUtils "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/utils"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource"
 	"github.com/hashicorp/terraform-plugin-framework/types"
-	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex"
+	"github.com/hashicorp/terraform-plugin-log/tflog"
+
+	"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"
 )
 
 // Ensure the implementation satisfies the expected interfaces.
@@ -28,36 +27,38 @@ var (
 	_ datasource.DataSource = &userDataSource{}
 )
 
-type DataSourceModel struct {
-	Id         types.String `tfsdk:"id"` // needed by TF
-	UserId     types.String `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"`
-	Host       types.String `tfsdk:"host"`
-	Port       types.Int64  `tfsdk:"port"`
-	Region     types.String `tfsdk:"region"`
-}
-
 // NewUserDataSource is a helper function to simplify the provider implementation.
 func NewUserDataSource() datasource.DataSource {
 	return &userDataSource{}
 }
 
+// dataSourceModel maps the data source schema data.
+type dataSourceModel struct {
+	postgresflexalpha.UserModel
+	TerraformID types.String `tfsdk:"id"`
+}
+
 // userDataSource is the data source implementation.
 type userDataSource struct {
-	client       *postgresflex.APIClient
+	client       *v3alpha1api.APIClient
 	providerData core.ProviderData
 }
 
 // Metadata returns the data source type name.
-func (r *userDataSource) Metadata(_ context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {
-	resp.TypeName = req.ProviderTypeName + "_postgresflex_user"
+func (r *userDataSource) Metadata(
+	_ context.Context,
+	req datasource.MetadataRequest,
+	resp *datasource.MetadataResponse,
+) {
+	resp.TypeName = req.ProviderTypeName + "_postgresflexalpha_user"
 }
 
 // Configure adds the provider configured client to the data source.
-func (r *userDataSource) Configure(ctx context.Context, req datasource.ConfigureRequest, resp *datasource.ConfigureResponse) {
+func (r *userDataSource) Configure(
+	ctx context.Context,
+	req datasource.ConfigureRequest,
+	resp *datasource.ConfigureResponse,
+) {
 	var ok bool
 	r.providerData, ok = conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
 	if !ok {
@@ -73,71 +74,25 @@ func (r *userDataSource) Configure(ctx context.Context, req datasource.Configure
 }
 
 // Schema defines the schema for the data source.
-func (r *userDataSource) Schema(_ context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
-	descriptions := map[string]string{
-		"main":        "Postgres Flex user data source schema. Must have a `region` specified in the provider configuration.",
-		"id":          "Terraform's internal data source. ID. It is structured as \"`project_id`,`region`,`instance_id`,`user_id`\".",
-		"user_id":     "User ID.",
-		"instance_id": "ID of the PostgresFlex instance.",
-		"project_id":  "STACKIT project ID to which the instance is associated.",
-		"region":      "The resource region. If not defined, the provider region is used.",
+func (r *userDataSource) Schema(ctx context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	s := postgresflexalpha.UserDataSourceSchema(ctx)
+	s.Attributes["id"] = schema.StringAttribute{
+		Description: "Terraform's internal resource ID. It is structured as \\\"`project_id`,`region`,`instance_id`," +
+			"`user_id`\\\".\",",
+		Optional: true,
+		Computed: true,
 	}
 
-	resp.Schema = schema.Schema{
-		Description: descriptions["main"],
-		Attributes: map[string]schema.Attribute{
-			"id": schema.StringAttribute{
-				Description: descriptions["id"],
-				Computed:    true,
-			},
-			"user_id": schema.StringAttribute{
-				Description: descriptions["user_id"],
-				Required:    true,
-				Validators: []validator.String{
-					validate.NoSeparator(),
-				},
-			},
-			"instance_id": schema.StringAttribute{
-				Description: descriptions["instance_id"],
-				Required:    true,
-				Validators: []validator.String{
-					validate.UUID(),
-					validate.NoSeparator(),
-				},
-			},
-			"project_id": schema.StringAttribute{
-				Description: descriptions["project_id"],
-				Required:    true,
-				Validators: []validator.String{
-					validate.UUID(),
-					validate.NoSeparator(),
-				},
-			},
-			"username": schema.StringAttribute{
-				Computed: true,
-			},
-			"roles": schema.SetAttribute{
-				ElementType: types.StringType,
-				Computed:    true,
-			},
-			"host": schema.StringAttribute{
-				Computed: true,
-			},
-			"port": schema.Int64Attribute{
-				Computed: true,
-			},
-			"region": schema.StringAttribute{
-				// the region cannot be found automatically, so it has to be passed
-				Optional:    true,
-				Description: descriptions["region"],
-			},
-		},
-	}
+	resp.Schema = s
 }
 
 // Read refreshes the Terraform state with the latest data.
-func (r *userDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) { // nolint:gocritic // function signature required by Terraform
-	var model DataSourceModel
+func (r *userDataSource) Read(
+	ctx context.Context,
+	req datasource.ReadRequest,
+	resp *datasource.ReadResponse,
+) { // nolint:gocritic // function signature required by Terraform
+	var model dataSourceModel
 	diags := req.Config.Get(ctx, &model)
 	resp.Diagnostics.Append(diags...)
 	if resp.Diagnostics.HasError() {
@@ -146,27 +101,24 @@ func (r *userDataSource) Read(ctx context.Context, req datasource.ReadRequest, r
 
 	ctx = core.InitProviderContext(ctx)
 
-	projectId := model.ProjectId.ValueString()
-	instanceId := model.InstanceId.ValueString()
-	userId := model.UserId.ValueString()
-	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)
+	projectID := model.ProjectId.ValueString()
+	instanceID := model.InstanceId.ValueString()
+	userID64 := model.UserId.ValueInt64()
+	if userID64 > math.MaxInt32 {
+		core.LogAndAddError(ctx, &resp.Diagnostics, "Error in type conversion", "int value too large (userId)")
+		return
+	}
+	userID := int32(userID64) // nolint:gosec // check is performed above
 
-	recordSetResp, err := r.client.GetUser(ctx, projectId, region, instanceId, userId).Execute()
+	region := r.providerData.GetRegionWithOverride(model.Region)
+	ctx = tflog.SetField(ctx, "project_id", projectID)
+	ctx = tflog.SetField(ctx, "instance_id", instanceID)
+	ctx = tflog.SetField(ctx, "region", region)
+	ctx = tflog.SetField(ctx, "user_id", userID)
+
+	recordSetResp, err := r.client.DefaultAPI.GetUserRequest(ctx, projectID, region, instanceID, userID).Execute()
 	if err != nil {
-		utils.LogError(
-			ctx,
-			&resp.Diagnostics,
-			err,
-			"Reading user",
-			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),
-			},
-		)
+		handleReadError(ctx, &diags, err, projectID, instanceID, userID)
 		resp.State.RemoveResource(ctx)
 		return
 	}
@@ -176,7 +128,12 @@ func (r *userDataSource) Read(ctx context.Context, req datasource.ReadRequest, r
 	// Map response body to schema and populate Computed attribute values
 	err = mapDataSourceFields(recordSetResp, &model, region)
 	if err != nil {
-		core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading user", fmt.Sprintf("Processing API payload: %v", err))
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"Error reading user",
+			fmt.Sprintf("Processing API payload: %v", err),
+		)
 		return
 	}
 
@@ -189,44 +146,38 @@ func (r *userDataSource) Read(ctx context.Context, req datasource.ReadRequest, r
 	tflog.Info(ctx, "Postgres Flex user read")
 }
 
-func mapDataSourceFields(userResp *postgresflex.GetUserResponse, model *DataSourceModel, region string) error {
-	if userResp == nil || userResp.Item == nil {
-		return fmt.Errorf("response is nil")
-	}
-	if model == nil {
-		return fmt.Errorf("model input is nil")
-	}
-	user := userResp.Item
-
-	var userId string
-	if model.UserId.ValueString() != "" {
-		userId = model.UserId.ValueString()
-	} 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(), userId,
+// handleReadError centralizes API error handling for the Read operation.
+func handleReadError(
+	ctx context.Context,
+	diags *diag.Diagnostics,
+	err error,
+	projectID, instanceID string,
+	userID int32,
+) {
+	utils.LogError(
+		ctx,
+		diags,
+		err,
+		"Reading user",
+		fmt.Sprintf(
+			"User with ID %q or instance with ID %q does not exist in project %q.",
+			userID,
+			instanceID,
+			projectID,
+		),
+		map[int]string{
+			http.StatusBadRequest: fmt.Sprintf(
+				"Invalid user request parameters for project %q and instance %q.",
+				projectID,
+				instanceID,
+			),
+			http.StatusNotFound: fmt.Sprintf(
+				"User, instance %q, or project %q or user %q not found.",
+				instanceID,
+				projectID,
+				userID,
+			),
+			http.StatusForbidden: fmt.Sprintf("Forbidden access to project %q.", projectID),
+		},
 	)
-	model.UserId = types.StringValue(userId)
-	model.Username = types.StringPointerValue(user.Username)
-
-	if user.Roles == nil {
-		model.Roles = types.SetNull(types.StringType)
-	} else {
-		roles := []attr.Value{}
-		for _, role := range *user.Roles {
-			roles = append(roles, types.StringValue(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
-	}
-	model.Host = types.StringPointerValue(user.Host)
-	model.Port = types.Int64PointerValue(user.Port)
-	model.Region = types.StringValue(region)
-	return nil
 }

stackit/internal/services/postgresflexalpha/user/datasource_test.go

@@ -1,146 +0,0 @@
-// Copyright (c) STACKIT
-
-package postgresflexa
-
-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"
-	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex"
-)
-
-func TestMapDataSourceFields(t *testing.T) {
-	const testRegion = "region"
-	tests := []struct {
-		description string
-		input       *postgresflex.GetUserResponse
-		region      string
-		expected    DataSourceModel
-		isValid     bool
-	}{
-		{
-			"default_values",
-			&postgresflex.GetUserResponse{
-				Item: &postgresflex.UserResponse{},
-			},
-			testRegion,
-			DataSourceModel{
-				Id:         types.StringValue("pid,region,iid,uid"),
-				UserId:     types.StringValue("uid"),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Username:   types.StringNull(),
-				Roles:      types.SetNull(types.StringType),
-				Host:       types.StringNull(),
-				Port:       types.Int64Null(),
-				Region:     types.StringValue(testRegion),
-			},
-			true,
-		},
-		{
-			"simple_values",
-			&postgresflex.GetUserResponse{
-				Item: &postgresflex.UserResponse{
-					Roles: &[]string{
-						"role_1",
-						"role_2",
-						"",
-					},
-					Username: utils.Ptr("username"),
-					Host:     utils.Ptr("host"),
-					Port:     utils.Ptr(int64(1234)),
-				},
-			},
-			testRegion,
-			DataSourceModel{
-				Id:         types.StringValue("pid,region,iid,uid"),
-				UserId:     types.StringValue("uid"),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Username:   types.StringValue("username"),
-				Roles: 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",
-			&postgresflex.GetUserResponse{
-				Item: &postgresflex.UserResponse{
-					Id:       utils.Ptr("uid"),
-					Roles:    &[]string{},
-					Username: nil,
-					Host:     nil,
-					Port:     utils.Ptr(int64(2123456789)),
-				},
-			},
-			testRegion,
-			DataSourceModel{
-				Id:         types.StringValue("pid,region,iid,uid"),
-				UserId:     types.StringValue("uid"),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Username:   types.StringNull(),
-				Roles:      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",
-			&postgresflex.GetUserResponse{},
-			testRegion,
-			DataSourceModel{},
-			false,
-		},
-		{
-			"no_resource_id",
-			&postgresflex.GetUserResponse{
-				Item: &postgresflex.UserResponse{},
-			},
-			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)
-				}
-			}
-		})
-	}
-}

stackit/internal/services/postgresflexalpha/user/datasources_gen/user_data_source_gen.go

@@ -0,0 +1,76 @@
+// Code generated by terraform-plugin-framework-generator DO NOT EDIT.
+
+package postgresflexalpha
+
+import (
+	"context"
+	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
+	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+)
+
+func UserDataSourceSchema(ctx context.Context) schema.Schema {
+	return schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"tf_original_api_id": schema.Int64Attribute{
+				Computed:            true,
+				Description:         "The ID of the user.",
+				MarkdownDescription: "The ID of the user.",
+			},
+			"instance_id": schema.StringAttribute{
+				Required:            true,
+				Description:         "The ID of the instance.",
+				MarkdownDescription: "The ID of the instance.",
+			},
+			"name": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The name of the user.",
+				MarkdownDescription: "The name of the user.",
+			},
+			"project_id": schema.StringAttribute{
+				Required:            true,
+				Description:         "The STACKIT project ID.",
+				MarkdownDescription: "The STACKIT project ID.",
+			},
+			"region": schema.StringAttribute{
+				Required:            true,
+				Description:         "The region which should be addressed",
+				MarkdownDescription: "The region which should be addressed",
+				Validators: []validator.String{
+					stringvalidator.OneOf(
+						"eu01",
+					),
+				},
+			},
+			"roles": schema.ListAttribute{
+				ElementType:         types.StringType,
+				Computed:            true,
+				Description:         "A list of user roles.",
+				MarkdownDescription: "A list of user roles.",
+			},
+			"status": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The current status of the user.",
+				MarkdownDescription: "The current status of the user.",
+			},
+			"user_id": schema.Int64Attribute{
+				Required:            true,
+				Description:         "The ID of the user.",
+				MarkdownDescription: "The ID of the user.",
+			},
+		},
+	}
+}
+
+type UserModel struct {
+	Id         types.Int64  `tfsdk:"tf_original_api_id"`
+	InstanceId types.String `tfsdk:"instance_id"`
+	Name       types.String `tfsdk:"name"`
+	ProjectId  types.String `tfsdk:"project_id"`
+	Region     types.String `tfsdk:"region"`
+	Roles      types.List   `tfsdk:"roles"`
+	Status     types.String `tfsdk:"status"`
+	UserId     types.Int64  `tfsdk:"user_id"`
+}

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

@@ -0,0 +1,139 @@
+package postgresflexalpha
+
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/hashicorp/terraform-plugin-framework/attr"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
+
+	"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 API response to data source model, preserving existing ID.
+func mapDataSourceFields(userResp *v3alpha1api.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
+
+	var userID int64
+	if model.UserId.ValueInt64() == 0 {
+		return fmt.Errorf("user id not present")
+	}
+	userID = model.UserId.ValueInt64()
+
+	model.TerraformID = utils.BuildInternalTerraformId(
+		model.ProjectId.ValueString(), region, model.InstanceId.ValueString(), strconv.FormatInt(userID, 10),
+	)
+
+	model.UserId = types.Int64Value(userID)
+	model.Name = types.StringValue(user.GetName())
+
+	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)
+	}
+
+	model.Id = types.Int64Value(userID)
+	model.Region = types.StringValue(region)
+	model.Status = types.StringValue(user.GetStatus())
+	return nil
+}
+
+// toPayloadRoles converts a string slice to the API's role type.
+func toPayloadRoles(roles []string) []v3alpha1api.UserRole {
+	var userRoles = make([]v3alpha1api.UserRole, 0, len(roles))
+	for _, role := range roles {
+		userRoles = append(userRoles, v3alpha1api.UserRole(role))
+	}
+	return userRoles
+}
+
+// toUpdatePayload creates an API update payload from the resource model.
+func toUpdatePayload(model *resourceModel, roles []string) (
+	*v3alpha1api.UpdateUserRequestPayload,
+	error,
+) {
+	if model == nil {
+		return nil, fmt.Errorf("nil model")
+	}
+	if roles == nil {
+		return nil, fmt.Errorf("nil roles")
+	}
+
+	return &v3alpha1api.UpdateUserRequestPayload{
+		Name:  model.Name.ValueStringPointer(),
+		Roles: toPayloadRoles(roles),
+	}, nil
+}
+
+// toCreatePayload creates an API create payload from the resource model.
+func toCreatePayload(model *resourceModel, roles []string) (*v3alpha1api.CreateUserRequestPayload, error) {
+	if model == nil {
+		return nil, fmt.Errorf("nil model")
+	}
+	if roles == nil {
+		return nil, fmt.Errorf("nil roles")
+	}
+
+	return &v3alpha1api.CreateUserRequestPayload{
+		Roles: toPayloadRoles(roles),
+		Name:  model.Name.ValueString(),
+	}, nil
+}
+
+// mapResourceFields maps API response to the resource model, preserving existing ID.
+func mapResourceFields(userResp *v3alpha1api.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
+
+	var userID int64
+	if !model.UserId.IsNull() && !model.UserId.IsUnknown() && model.UserId.ValueInt64() != 0 {
+		userID = model.UserId.ValueInt64()
+	} else if user.Id != 0 {
+		userID = int64(user.Id)
+	} else {
+		return fmt.Errorf("user id not present")
+	}
+
+	model.Id = types.Int64Value(userID)
+	model.UserId = types.Int64Value(userID)
+	model.Name = types.StringValue(user.Name)
+
+	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)
+	}
+	model.Region = types.StringValue(region)
+	model.Status = types.StringValue(user.Status)
+	return nil
+}

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

@@ -0,0 +1,573 @@
+package postgresflexalpha
+
+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"
+
+	postgresflex "github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
+
+	data "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/user/datasources_gen"
+)
+
+func TestMapDataSourceFields(t *testing.T) {
+	const testRegion = "region"
+	tests := []struct {
+		description string
+		input       *postgresflex.GetUserResponse
+		region      string
+		expected    dataSourceModel
+		isValid     bool
+	}{
+		{
+			"default_values",
+			&postgresflex.GetUserResponse{},
+			testRegion,
+			dataSourceModel{
+				UserModel: data.UserModel{
+					Id:         types.Int64Value(1),
+					UserId:     types.Int64Value(1),
+					InstanceId: types.StringValue("iid"),
+					ProjectId:  types.StringValue("pid"),
+					Name:       types.StringValue(""),
+					Roles:      types.List(types.SetNull(types.StringType)),
+					Status:     types.StringValue(""),
+					Region:     types.StringValue(testRegion),
+				},
+				TerraformID: types.StringValue("pid,region,iid,1"),
+			},
+			true,
+		},
+		{
+			"simple_values",
+			&postgresflex.GetUserResponse{
+				Roles: []postgresflex.UserRole{
+					"role_1",
+					"role_2",
+					"",
+				},
+				Name: "username",
+			},
+			testRegion,
+			dataSourceModel{
+				UserModel: data.UserModel{
+					Id:         types.Int64Value(1),
+					UserId:     types.Int64Value(1),
+					InstanceId: types.StringValue("iid"),
+					ProjectId:  types.StringValue("pid"),
+					Name:       types.StringValue("username"),
+					Roles: types.List(
+						types.SetValueMust(
+							types.StringType, []attr.Value{
+								types.StringValue("role_1"),
+								types.StringValue("role_2"),
+								types.StringValue(""),
+							},
+						),
+					),
+					Region: types.StringValue(testRegion),
+					Status: types.StringValue(""),
+				},
+				TerraformID: types.StringValue("pid,region,iid,1"),
+			},
+			true,
+		},
+		{
+			"null_fields_and_int_conversions",
+			&postgresflex.GetUserResponse{
+				Id:     int32(1),
+				Roles:  []postgresflex.UserRole{},
+				Name:   "",
+				Status: "status",
+			},
+			testRegion,
+			dataSourceModel{
+				UserModel: data.UserModel{
+					Id:         types.Int64Value(1),
+					UserId:     types.Int64Value(1),
+					InstanceId: types.StringValue("iid"),
+					ProjectId:  types.StringValue("pid"),
+					Name:       types.StringValue(""),
+					Roles:      types.List(types.SetValueMust(types.StringType, []attr.Value{})),
+					Region:     types.StringValue(testRegion),
+					Status:     types.StringValue("status"),
+				},
+				TerraformID: types.StringValue("pid,region,iid,1"),
+			},
+			true,
+		},
+		{
+			"nil_response",
+			nil,
+			testRegion,
+			dataSourceModel{},
+			false,
+		},
+		{
+			"nil_response_2",
+			&postgresflex.GetUserResponse{},
+			testRegion,
+			dataSourceModel{},
+			false,
+		},
+		{
+			"no_resource_id",
+			&postgresflex.GetUserResponse{},
+			testRegion,
+			dataSourceModel{},
+			false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(
+			tt.description, func(t *testing.T) {
+				state := &dataSourceModel{
+					UserModel: data.UserModel{
+						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       *postgresflex.GetUserResponse
+		region      string
+		expected    resourceModel
+		isValid     bool
+	}{
+		{
+			"default_values",
+			&postgresflex.GetUserResponse{
+				Id: int32(1),
+			},
+			testRegion,
+			resourceModel{
+				Id:         types.Int64Value(1),
+				UserId:     types.Int64Value(1),
+				InstanceId: types.StringValue("iid"),
+				ProjectId:  types.StringValue("pid"),
+				Name:       types.StringValue(""),
+				Roles:      types.List(types.SetNull(types.StringType)),
+				Password:   types.StringNull(),
+				Region:     types.StringValue(testRegion),
+				Status:     types.StringValue(""),
+				//ConnectionString: types.StringNull(),
+			},
+			true,
+		},
+		{
+			"simple_values",
+			&postgresflex.GetUserResponse{
+				Id:     int32(1),
+				Name:   "username",
+				Status: "status",
+			},
+			testRegion,
+			resourceModel{
+				Id:         types.Int64Value(1),
+				UserId:     types.Int64Value(1),
+				InstanceId: types.StringValue("iid"),
+				ProjectId:  types.StringValue("pid"),
+				Name:       types.StringValue("username"),
+				Roles:      types.List(types.SetNull(types.StringType)),
+				Password:   types.StringNull(),
+				Region:     types.StringValue(testRegion),
+				Status:     types.StringValue("status"),
+				//ConnectionString: types.StringNull(),
+			},
+			true,
+		},
+		{
+			"null_fields_and_int_conversions",
+			&postgresflex.GetUserResponse{
+				Id:     int32(1),
+				Name:   "",
+				Status: "",
+			},
+			testRegion,
+			resourceModel{
+				Id:         types.Int64Value(1),
+				UserId:     types.Int64Value(1),
+				InstanceId: types.StringValue("iid"),
+				ProjectId:  types.StringValue("pid"),
+				Name:       types.StringValue(""),
+				Roles:      types.List(types.SetNull(types.StringType)),
+				Password:   types.StringNull(),
+				Region:     types.StringValue(testRegion),
+				Status:     types.StringValue(""),
+				//ConnectionString: types.StringNull(),
+			},
+			true,
+		},
+		{
+			"nil_response",
+			nil,
+			testRegion,
+			resourceModel{},
+			false,
+		},
+		{
+			"nil_response_2",
+			&postgresflex.GetUserResponse{},
+			testRegion,
+			resourceModel{},
+			false,
+		},
+		{
+			"no_resource_id",
+			&postgresflex.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,
+				}
+
+				err := mapResourceFields(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(&tt.expected, state)
+					if diff != "" {
+						t.Fatalf("Data does not match: %s", diff)
+					}
+				}
+			},
+		)
+	}
+}
+
+func TestMapFields(t *testing.T) {
+	const testRegion = "region"
+	tests := []struct {
+		description string
+		input       *postgresflex.GetUserResponse
+		region      string
+		expected    resourceModel
+		isValid     bool
+	}{
+		{
+			"default_values",
+			&postgresflex.GetUserResponse{
+				Id: int32(1),
+			},
+			testRegion,
+			resourceModel{
+				Id:         types.Int64Value(1),
+				UserId:     types.Int64Value(int64(1)),
+				InstanceId: types.StringValue("iid"),
+				ProjectId:  types.StringValue("pid"),
+				Name:       types.StringValue(""),
+				Roles:      types.List(types.SetNull(types.StringType)),
+				Region:     types.StringValue(testRegion),
+				Status:     types.StringValue(""),
+				//ConnectionString: types.StringNull(),
+			},
+			true,
+		},
+		{
+			"simple_values",
+			&postgresflex.GetUserResponse{
+				Id: int32(1),
+				Roles: []postgresflex.UserRole{
+					"role_1",
+					"role_2",
+					"",
+				},
+				Name: "username",
+			},
+			testRegion,
+			resourceModel{
+				Id:         types.Int64Value(1),
+				UserId:     types.Int64Value(1),
+				InstanceId: types.StringValue("iid"),
+				ProjectId:  types.StringValue("pid"),
+				Name:       types.StringValue("username"),
+				Roles: types.List(
+					types.SetValueMust(
+						types.StringType, []attr.Value{
+							types.StringValue("role_1"),
+							types.StringValue("role_2"),
+							types.StringValue(""),
+						},
+					),
+				),
+				Region: types.StringValue(testRegion),
+				Status: types.StringValue(""),
+				//ConnectionString: types.StringNull(),
+			},
+			true,
+		},
+		{
+			"null_fields_and_int_conversions",
+			&postgresflex.GetUserResponse{
+				Id:   int32(1),
+				Name: "",
+			},
+			testRegion,
+			resourceModel{
+				Id:         types.Int64Value(1),
+				UserId:     types.Int64Value(1),
+				InstanceId: types.StringValue("iid"),
+				ProjectId:  types.StringValue("pid"),
+				Name:       types.StringValue(""),
+				Roles:      types.List(types.SetNull(types.StringType)),
+				Region:     types.StringValue(testRegion),
+				Status:     types.StringValue(""),
+				//ConnectionString: types.StringNull(),
+			},
+			true,
+		},
+		{
+			"nil_response",
+			nil,
+			testRegion,
+			resourceModel{},
+			false,
+		},
+		{
+			"nil_response_2",
+			&postgresflex.GetUserResponse{},
+			testRegion,
+			resourceModel{},
+			false,
+		},
+		{
+			"no_resource_id",
+			&postgresflex.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,
+				}
+				err := mapResourceFields(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  []string
+		expected    *postgresflex.CreateUserRequestPayload
+		isValid     bool
+	}{
+		{
+			"default_values",
+			&resourceModel{},
+			[]string{},
+			&postgresflex.CreateUserRequestPayload{
+				Name:  "",
+				Roles: []postgresflex.UserRole{},
+			},
+			true,
+		},
+		{
+			"simple_values",
+			&resourceModel{
+				Name: types.StringValue("username"),
+			},
+			[]string{
+				"role_1",
+				"role_2",
+			},
+			&postgresflex.CreateUserRequestPayload{
+				Name: "username",
+				Roles: []postgresflex.UserRole{
+					"role_1",
+					"role_2",
+				},
+			},
+			true,
+		},
+		{
+			"null_fields_and_int_conversions",
+			&resourceModel{
+				Name: types.StringNull(),
+			},
+			[]string{
+				"",
+			},
+			&postgresflex.CreateUserRequestPayload{
+				Roles: []postgresflex.UserRole{
+					"",
+				},
+				Name: "",
+			},
+			true,
+		},
+		{
+			"nil_model",
+			nil,
+			[]string{},
+			nil,
+			false,
+		},
+		{
+			"nil_roles",
+			&resourceModel{},
+			nil,
+			nil,
+			false,
+		},
+	}
+	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)
+					}
+				}
+			},
+		)
+	}
+}
+
+func TestToUpdatePayload(t *testing.T) {
+	tests := []struct {
+		description string
+		input       *resourceModel
+		inputRoles  []string
+		expected    *postgresflex.UpdateUserRequestPayload
+		isValid     bool
+	}{
+		{
+			"default_values",
+			&resourceModel{},
+			[]string{},
+			&postgresflex.UpdateUserRequestPayload{
+				Roles: []postgresflex.UserRole{},
+			},
+			true,
+		},
+		{
+			"default_values",
+			&resourceModel{
+				Name: types.StringValue("username"),
+			},
+			[]string{
+				"role_1",
+				"role_2",
+			},
+			&postgresflex.UpdateUserRequestPayload{
+				Name: utils.Ptr("username"),
+				Roles: []postgresflex.UserRole{
+					"role_1",
+					"role_2",
+				},
+			},
+			true,
+		},
+		{
+			"null_fields_and_int_conversions",
+			&resourceModel{
+				Name: types.StringNull(),
+			},
+			[]string{
+				"",
+			},
+			&postgresflex.UpdateUserRequestPayload{
+				Roles: []postgresflex.UserRole{
+					"",
+				},
+			},
+			true,
+		},
+		{
+			"nil_model",
+			nil,
+			[]string{},
+			nil,
+			false,
+		},
+		{
+			"nil_roles",
+			&resourceModel{},
+			nil,
+			nil,
+			false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(
+			tt.description, func(t *testing.T) {
+				output, err := toUpdatePayload(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/postgresflexalpha/user/planModifiers.yaml

@@ -0,0 +1,64 @@
+fields:
+  - name: 'id'
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'user_id'
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'instance_id'
+    validators:
+      - validate.NoSeparator
+      - validate.UUID
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'project_id'
+    validators:
+      - validate.NoSeparator
+      - validate.UUID
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'name'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'roles'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'password'
+    modifiers:
+      - 'RequiresReplace'
+      - 'UseStateForUnknown'
+
+  - name: 'host'
+    modifiers:
+      - 'RequiresReplace'
+      - 'UseStateForUnknown'
+
+  - name: 'port'
+    modifiers:
+      - 'RequiresReplace'
+      - 'UseStateForUnknown'
+
+  - name: 'region'
+    modifiers:
+      - 'RequiresReplace'
+      - 'RequiresReplace'
+
+  - name: 'status'
+    modifiers:
+      - 'RequiresReplace'
+      - 'UseStateForUnknown'
+
+  - name: 'connection_string'
+    modifiers:
+      - 'RequiresReplace'
+      - 'UseStateForUnknown'

stackit/internal/services/postgresflexalpha/user/resource_test.go

@@ -1,472 +0,0 @@
-// Copyright (c) STACKIT
-
-package postgresflexa
-
-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"
-	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex"
-)
-
-func TestMapFieldsCreate(t *testing.T) {
-	const testRegion = "region"
-	tests := []struct {
-		description string
-		input       *postgresflex.CreateUserResponse
-		region      string
-		expected    Model
-		isValid     bool
-	}{
-		{
-			"default_values",
-			&postgresflex.CreateUserResponse{
-				Item: &postgresflex.User{
-					Id:       utils.Ptr("uid"),
-					Password: utils.Ptr(""),
-				},
-			},
-			testRegion,
-			Model{
-				Id:         types.StringValue("pid,region,iid,uid"),
-				UserId:     types.StringValue("uid"),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Username:   types.StringNull(),
-				Roles:      types.SetNull(types.StringType),
-				Password:   types.StringValue(""),
-				Host:       types.StringNull(),
-				Port:       types.Int64Null(),
-				Uri:        types.StringNull(),
-				Region:     types.StringValue(testRegion),
-			},
-			true,
-		},
-		{
-			"simple_values",
-			&postgresflex.CreateUserResponse{
-				Item: &postgresflex.User{
-					Id: utils.Ptr("uid"),
-					Roles: &[]string{
-						"role_1",
-						"role_2",
-						"",
-					},
-					Username: utils.Ptr("username"),
-					Password: utils.Ptr("password"),
-					Host:     utils.Ptr("host"),
-					Port:     utils.Ptr(int64(1234)),
-					Uri:      utils.Ptr("uri"),
-				},
-			},
-			testRegion,
-			Model{
-				Id:         types.StringValue("pid,region,iid,uid"),
-				UserId:     types.StringValue("uid"),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Username:   types.StringValue("username"),
-				Roles: 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),
-				Uri:      types.StringValue("uri"),
-				Region:   types.StringValue(testRegion),
-			},
-			true,
-		},
-		{
-			"null_fields_and_int_conversions",
-			&postgresflex.CreateUserResponse{
-				Item: &postgresflex.User{
-					Id:       utils.Ptr("uid"),
-					Roles:    &[]string{},
-					Username: nil,
-					Password: utils.Ptr(""),
-					Host:     nil,
-					Port:     utils.Ptr(int64(2123456789)),
-					Uri:      nil,
-				},
-			},
-			testRegion,
-			Model{
-				Id:         types.StringValue("pid,region,iid,uid"),
-				UserId:     types.StringValue("uid"),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Username:   types.StringNull(),
-				Roles:      types.SetValueMust(types.StringType, []attr.Value{}),
-				Password:   types.StringValue(""),
-				Host:       types.StringNull(),
-				Port:       types.Int64Value(2123456789),
-				Uri:        types.StringNull(),
-				Region:     types.StringValue(testRegion),
-			},
-			true,
-		},
-		{
-			"nil_response",
-			nil,
-			testRegion,
-			Model{},
-			false,
-		},
-		{
-			"nil_response_2",
-			&postgresflex.CreateUserResponse{},
-			testRegion,
-			Model{},
-			false,
-		},
-		{
-			"no_resource_id",
-			&postgresflex.CreateUserResponse{
-				Item: &postgresflex.User{},
-			},
-			testRegion,
-			Model{},
-			false,
-		},
-		{
-			"no_password",
-			&postgresflex.CreateUserResponse{
-				Item: &postgresflex.User{
-					Id: utils.Ptr("uid"),
-				},
-			},
-			testRegion,
-			Model{},
-			false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.description, func(t *testing.T) {
-			state := &Model{
-				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       *postgresflex.GetUserResponse
-		region      string
-		expected    Model
-		isValid     bool
-	}{
-		{
-			"default_values",
-			&postgresflex.GetUserResponse{
-				Item: &postgresflex.UserResponse{},
-			},
-			testRegion,
-			Model{
-				Id:         types.StringValue("pid,region,iid,uid"),
-				UserId:     types.StringValue("uid"),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Username:   types.StringNull(),
-				Roles:      types.SetNull(types.StringType),
-				Host:       types.StringNull(),
-				Port:       types.Int64Null(),
-				Region:     types.StringValue(testRegion),
-			},
-			true,
-		},
-		{
-			"simple_values",
-			&postgresflex.GetUserResponse{
-				Item: &postgresflex.UserResponse{
-					Roles: &[]string{
-						"role_1",
-						"role_2",
-						"",
-					},
-					Username: utils.Ptr("username"),
-					Host:     utils.Ptr("host"),
-					Port:     utils.Ptr(int64(1234)),
-				},
-			},
-			testRegion,
-			Model{
-				Id:         types.StringValue("pid,region,iid,uid"),
-				UserId:     types.StringValue("uid"),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Username:   types.StringValue("username"),
-				Roles: 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",
-			&postgresflex.GetUserResponse{
-				Item: &postgresflex.UserResponse{
-					Id:       utils.Ptr("uid"),
-					Roles:    &[]string{},
-					Username: nil,
-					Host:     nil,
-					Port:     utils.Ptr(int64(2123456789)),
-				},
-			},
-			testRegion,
-			Model{
-				Id:         types.StringValue("pid,region,iid,uid"),
-				UserId:     types.StringValue("uid"),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Username:   types.StringNull(),
-				Roles:      types.SetValueMust(types.StringType, []attr.Value{}),
-				Host:       types.StringNull(),
-				Port:       types.Int64Value(2123456789),
-				Region:     types.StringValue(testRegion),
-			},
-			true,
-		},
-		{
-			"nil_response",
-			nil,
-			testRegion,
-			Model{},
-			false,
-		},
-		{
-			"nil_response_2",
-			&postgresflex.GetUserResponse{},
-			testRegion,
-			Model{},
-			false,
-		},
-		{
-			"no_resource_id",
-			&postgresflex.GetUserResponse{
-				Item: &postgresflex.UserResponse{},
-			},
-			testRegion,
-			Model{},
-			false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.description, func(t *testing.T) {
-			state := &Model{
-				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       *Model
-		inputRoles  []string
-		expected    *postgresflex.CreateUserPayload
-		isValid     bool
-	}{
-		{
-			"default_values",
-			&Model{},
-			[]string{},
-			&postgresflex.CreateUserPayload{
-				Roles:    &[]string{},
-				Username: nil,
-			},
-			true,
-		},
-		{
-			"default_values",
-			&Model{
-				Username: types.StringValue("username"),
-			},
-			[]string{
-				"role_1",
-				"role_2",
-			},
-			&postgresflex.CreateUserPayload{
-				Roles: &[]string{
-					"role_1",
-					"role_2",
-				},
-				Username: utils.Ptr("username"),
-			},
-			true,
-		},
-		{
-			"null_fields_and_int_conversions",
-			&Model{
-				Username: types.StringNull(),
-			},
-			[]string{
-				"",
-			},
-			&postgresflex.CreateUserPayload{
-				Roles: &[]string{
-					"",
-				},
-				Username: nil,
-			},
-			true,
-		},
-		{
-			"nil_model",
-			nil,
-			[]string{},
-			nil,
-			false,
-		},
-		{
-			"nil_roles",
-			&Model{},
-			nil,
-			nil,
-			false,
-		},
-	}
-	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)
-				}
-			}
-		})
-	}
-}
-
-func TestToUpdatePayload(t *testing.T) {
-	tests := []struct {
-		description string
-		input       *Model
-		inputRoles  []string
-		expected    *postgresflex.UpdateUserPayload
-		isValid     bool
-	}{
-		{
-			"default_values",
-			&Model{},
-			[]string{},
-			&postgresflex.UpdateUserPayload{
-				Roles: &[]string{},
-			},
-			true,
-		},
-		{
-			"default_values",
-			&Model{
-				Username: types.StringValue("username"),
-			},
-			[]string{
-				"role_1",
-				"role_2",
-			},
-			&postgresflex.UpdateUserPayload{
-				Roles: &[]string{
-					"role_1",
-					"role_2",
-				},
-			},
-			true,
-		},
-		{
-			"null_fields_and_int_conversions",
-			&Model{
-				Username: types.StringNull(),
-			},
-			[]string{
-				"",
-			},
-			&postgresflex.UpdateUserPayload{
-				Roles: &[]string{
-					"",
-				},
-			},
-			true,
-		},
-		{
-			"nil_model",
-			nil,
-			[]string{},
-			nil,
-			false,
-		},
-		{
-			"nil_roles",
-			&Model{},
-			nil,
-			nil,
-			false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.description, func(t *testing.T) {
-			output, err := toUpdatePayload(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/postgresflexalpha/user/resources_gen/user_resource_gen.go

@@ -0,0 +1,87 @@
+// Code generated by terraform-plugin-framework-generator DO NOT EDIT.
+
+package postgresflexalpha
+
+import (
+	"context"
+	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
+	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema"
+)
+
+func UserResourceSchema(ctx context.Context) schema.Schema {
+	return schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"id": schema.Int64Attribute{
+				Computed:            true,
+				Description:         "The ID of the user.",
+				MarkdownDescription: "The ID of the user.",
+			},
+			"instance_id": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The ID of the instance.",
+				MarkdownDescription: "The ID of the instance.",
+			},
+			"name": schema.StringAttribute{
+				Required:            true,
+				Description:         "The name of the user.",
+				MarkdownDescription: "The name of the user.",
+			},
+			"password": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The password for the user.",
+				MarkdownDescription: "The password for the user.",
+			},
+			"project_id": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The STACKIT project ID.",
+				MarkdownDescription: "The STACKIT project ID.",
+			},
+			"region": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The region which should be addressed",
+				MarkdownDescription: "The region which should be addressed",
+				Validators: []validator.String{
+					stringvalidator.OneOf(
+						"eu01",
+					),
+				},
+			},
+			"roles": schema.ListAttribute{
+				ElementType:         types.StringType,
+				Optional:            true,
+				Computed:            true,
+				Description:         "A list containing the user roles for the instance.",
+				MarkdownDescription: "A list containing the user roles for the instance.",
+			},
+			"status": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The current status of the user.",
+				MarkdownDescription: "The current status of the user.",
+			},
+			"user_id": schema.Int64Attribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The ID of the user.",
+				MarkdownDescription: "The ID of the user.",
+			},
+		},
+	}
+}
+
+type UserModel struct {
+	Id         types.Int64  `tfsdk:"id"`
+	InstanceId types.String `tfsdk:"instance_id"`
+	Name       types.String `tfsdk:"name"`
+	Password   types.String `tfsdk:"password"`
+	ProjectId  types.String `tfsdk:"project_id"`
+	Region     types.String `tfsdk:"region"`
+	Roles      types.List   `tfsdk:"roles"`
+	Status     types.String `tfsdk:"status"`
+	UserId     types.Int64  `tfsdk:"user_id"`
+}

stackit/internal/services/postgresflexalpha/utils/util.go

@@ -8,10 +8,11 @@ import (
 
 	"github.com/hashicorp/terraform-plugin-framework/diag"
 	"github.com/stackitcloud/stackit-sdk-go/core/config"
-	postgresflex "github.com/stackitcloud/terraform-provider-stackit/pkg/postgresflexalpha"
 
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/utils"
+	postgresflex "github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
+
+	"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"
 )
 
 func ConfigureClient(ctx context.Context, providerData *core.ProviderData, diags *diag.Diagnostics) *postgresflex.APIClient {

stackit/internal/services/postgresflexalpha/utils/util_test.go

@@ -11,9 +11,11 @@ import (
 	"github.com/hashicorp/terraform-plugin-framework/diag"
 	sdkClients "github.com/stackitcloud/stackit-sdk-go/core/clients"
 	"github.com/stackitcloud/stackit-sdk-go/core/config"
-	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/utils"
+
+	"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"
+
+	"github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v3alpha1api"
 )
 
 const (
@@ -36,7 +38,7 @@ func TestConfigureClient(t *testing.T) {
 		name     string
 		args     args
 		wantErr  bool
-		expected *postgresflex.APIClient
+		expected *v3alpha1api.APIClient
 	}{
 		{
 			name: "default endpoint",
@@ -45,8 +47,8 @@ func TestConfigureClient(t *testing.T) {
 					Version: testVersion,
 				},
 			},
-			expected: func() *postgresflex.APIClient {
-				apiClient, err := postgresflex.NewAPIClient(
+			expected: func() *v3alpha1api.APIClient {
+				apiClient, err := v3alpha1api.NewAPIClient(
 					config.WithRegion("eu01"),
 					utils.UserAgentConfigOption(testVersion),
 				)
@@ -65,8 +67,8 @@ func TestConfigureClient(t *testing.T) {
 					PostgresFlexCustomEndpoint: testCustomEndpoint,
 				},
 			},
-			expected: func() *postgresflex.APIClient {
-				apiClient, err := postgresflex.NewAPIClient(
+			expected: func() *v3alpha1api.APIClient {
+				apiClient, err := v3alpha1api.NewAPIClient(
 					utils.UserAgentConfigOption(testVersion),
 					config.WithEndpoint(testCustomEndpoint),
 				)

stackit/internal/services/postgresflexalpha/version/datasources_gen/versions_data_source_gen.go

@@ -0,0 +1,569 @@
+// Code generated by terraform-plugin-framework-generator DO NOT EDIT.
+
+package postgresflexalpha
+
+import (
+	"context"
+	"fmt"
+	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
+	"github.com/hashicorp/terraform-plugin-framework/attr"
+	"github.com/hashicorp/terraform-plugin-framework/diag"
+	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
+	"github.com/hashicorp/terraform-plugin-go/tftypes"
+	"strings"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+)
+
+func VersionsDataSourceSchema(ctx context.Context) schema.Schema {
+	return schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"project_id": schema.StringAttribute{
+				Required:            true,
+				Description:         "The STACKIT project ID.",
+				MarkdownDescription: "The STACKIT project ID.",
+			},
+			"region": schema.StringAttribute{
+				Required:            true,
+				Description:         "The region which should be addressed",
+				MarkdownDescription: "The region which should be addressed",
+				Validators: []validator.String{
+					stringvalidator.OneOf(
+						"eu01",
+					),
+				},
+			},
+			"versions": schema.ListNestedAttribute{
+				NestedObject: schema.NestedAttributeObject{
+					Attributes: map[string]schema.Attribute{
+						"beta": schema.BoolAttribute{
+							Computed:            true,
+							Description:         "Flag if the version is a beta version. If set the version may contain bugs and is not fully tested.",
+							MarkdownDescription: "Flag if the version is a beta version. If set the version may contain bugs and is not fully tested.",
+						},
+						"deprecated": schema.StringAttribute{
+							Computed:            true,
+							Description:         "Timestamp in RFC3339 format which says when the version will no longer be supported by STACKIT.",
+							MarkdownDescription: "Timestamp in RFC3339 format which says when the version will no longer be supported by STACKIT.",
+						},
+						"recommend": schema.BoolAttribute{
+							Computed:            true,
+							Description:         "Flag if the version is recommend by the STACKIT Team.",
+							MarkdownDescription: "Flag if the version is recommend by the STACKIT Team.",
+						},
+						"version": schema.StringAttribute{
+							Computed:            true,
+							Description:         "The postgres version used for the instance.",
+							MarkdownDescription: "The postgres version used for the instance.",
+						},
+					},
+					CustomType: VersionsType{
+						ObjectType: types.ObjectType{
+							AttrTypes: VersionsValue{}.AttributeTypes(ctx),
+						},
+					},
+				},
+				Computed:            true,
+				Description:         "A list containing available postgres versions.",
+				MarkdownDescription: "A list containing available postgres versions.",
+			},
+		},
+	}
+}
+
+type VersionsModel struct {
+	ProjectId types.String `tfsdk:"project_id"`
+	Region    types.String `tfsdk:"region"`
+	Versions  types.List   `tfsdk:"versions"`
+}
+
+var _ basetypes.ObjectTypable = VersionsType{}
+
+type VersionsType struct {
+	basetypes.ObjectType
+}
+
+func (t VersionsType) Equal(o attr.Type) bool {
+	other, ok := o.(VersionsType)
+
+	if !ok {
+		return false
+	}
+
+	return t.ObjectType.Equal(other.ObjectType)
+}
+
+func (t VersionsType) String() string {
+	return "VersionsType"
+}
+
+func (t VersionsType) ValueFromObject(ctx context.Context, in basetypes.ObjectValue) (basetypes.ObjectValuable, diag.Diagnostics) {
+	var diags diag.Diagnostics
+
+	attributes := in.Attributes()
+
+	betaAttribute, ok := attributes["beta"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`beta is missing from object`)
+
+		return nil, diags
+	}
+
+	betaVal, ok := betaAttribute.(basetypes.BoolValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`beta expected to be basetypes.BoolValue, was: %T`, betaAttribute))
+	}
+
+	deprecatedAttribute, ok := attributes["deprecated"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`deprecated is missing from object`)
+
+		return nil, diags
+	}
+
+	deprecatedVal, ok := deprecatedAttribute.(basetypes.StringValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`deprecated expected to be basetypes.StringValue, was: %T`, deprecatedAttribute))
+	}
+
+	recommendAttribute, ok := attributes["recommend"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`recommend is missing from object`)
+
+		return nil, diags
+	}
+
+	recommendVal, ok := recommendAttribute.(basetypes.BoolValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`recommend expected to be basetypes.BoolValue, was: %T`, recommendAttribute))
+	}
+
+	versionAttribute, ok := attributes["version"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`version is missing from object`)
+
+		return nil, diags
+	}
+
+	versionVal, ok := versionAttribute.(basetypes.StringValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`version expected to be basetypes.StringValue, was: %T`, versionAttribute))
+	}
+
+	if diags.HasError() {
+		return nil, diags
+	}
+
+	return VersionsValue{
+		Beta:       betaVal,
+		Deprecated: deprecatedVal,
+		Recommend:  recommendVal,
+		Version:    versionVal,
+		state:      attr.ValueStateKnown,
+	}, diags
+}
+
+func NewVersionsValueNull() VersionsValue {
+	return VersionsValue{
+		state: attr.ValueStateNull,
+	}
+}
+
+func NewVersionsValueUnknown() VersionsValue {
+	return VersionsValue{
+		state: attr.ValueStateUnknown,
+	}
+}
+
+func NewVersionsValue(attributeTypes map[string]attr.Type, attributes map[string]attr.Value) (VersionsValue, diag.Diagnostics) {
+	var diags diag.Diagnostics
+
+	// Reference: https://github.com/hashicorp/terraform-plugin-framework/issues/521
+	ctx := context.Background()
+
+	for name, attributeType := range attributeTypes {
+		attribute, ok := attributes[name]
+
+		if !ok {
+			diags.AddError(
+				"Missing VersionsValue Attribute Value",
+				"While creating a VersionsValue value, a missing attribute value was detected. "+
+					"A VersionsValue must contain values for all attributes, even if null or unknown. "+
+					"This is always an issue with the provider and should be reported to the provider developers.\n\n"+
+					fmt.Sprintf("VersionsValue Attribute Name (%s) Expected Type: %s", name, attributeType.String()),
+			)
+
+			continue
+		}
+
+		if !attributeType.Equal(attribute.Type(ctx)) {
+			diags.AddError(
+				"Invalid VersionsValue Attribute Type",
+				"While creating a VersionsValue value, an invalid attribute value was detected. "+
+					"A VersionsValue must use a matching attribute type for the value. "+
+					"This is always an issue with the provider and should be reported to the provider developers.\n\n"+
+					fmt.Sprintf("VersionsValue Attribute Name (%s) Expected Type: %s\n", name, attributeType.String())+
+					fmt.Sprintf("VersionsValue Attribute Name (%s) Given Type: %s", name, attribute.Type(ctx)),
+			)
+		}
+	}
+
+	for name := range attributes {
+		_, ok := attributeTypes[name]
+
+		if !ok {
+			diags.AddError(
+				"Extra VersionsValue Attribute Value",
+				"While creating a VersionsValue value, an extra attribute value was detected. "+
+					"A VersionsValue must not contain values beyond the expected attribute types. "+
+					"This is always an issue with the provider and should be reported to the provider developers.\n\n"+
+					fmt.Sprintf("Extra VersionsValue Attribute Name: %s", name),
+			)
+		}
+	}
+
+	if diags.HasError() {
+		return NewVersionsValueUnknown(), diags
+	}
+
+	betaAttribute, ok := attributes["beta"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`beta is missing from object`)
+
+		return NewVersionsValueUnknown(), diags
+	}
+
+	betaVal, ok := betaAttribute.(basetypes.BoolValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`beta expected to be basetypes.BoolValue, was: %T`, betaAttribute))
+	}
+
+	deprecatedAttribute, ok := attributes["deprecated"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`deprecated is missing from object`)
+
+		return NewVersionsValueUnknown(), diags
+	}
+
+	deprecatedVal, ok := deprecatedAttribute.(basetypes.StringValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`deprecated expected to be basetypes.StringValue, was: %T`, deprecatedAttribute))
+	}
+
+	recommendAttribute, ok := attributes["recommend"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`recommend is missing from object`)
+
+		return NewVersionsValueUnknown(), diags
+	}
+
+	recommendVal, ok := recommendAttribute.(basetypes.BoolValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`recommend expected to be basetypes.BoolValue, was: %T`, recommendAttribute))
+	}
+
+	versionAttribute, ok := attributes["version"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`version is missing from object`)
+
+		return NewVersionsValueUnknown(), diags
+	}
+
+	versionVal, ok := versionAttribute.(basetypes.StringValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`version expected to be basetypes.StringValue, was: %T`, versionAttribute))
+	}
+
+	if diags.HasError() {
+		return NewVersionsValueUnknown(), diags
+	}
+
+	return VersionsValue{
+		Beta:       betaVal,
+		Deprecated: deprecatedVal,
+		Recommend:  recommendVal,
+		Version:    versionVal,
+		state:      attr.ValueStateKnown,
+	}, diags
+}
+
+func NewVersionsValueMust(attributeTypes map[string]attr.Type, attributes map[string]attr.Value) VersionsValue {
+	object, diags := NewVersionsValue(attributeTypes, attributes)
+
+	if diags.HasError() {
+		// This could potentially be added to the diag package.
+		diagsStrings := make([]string, 0, len(diags))
+
+		for _, diagnostic := range diags {
+			diagsStrings = append(diagsStrings, fmt.Sprintf(
+				"%s | %s | %s",
+				diagnostic.Severity(),
+				diagnostic.Summary(),
+				diagnostic.Detail()))
+		}
+
+		panic("NewVersionsValueMust received error(s): " + strings.Join(diagsStrings, "\n"))
+	}
+
+	return object
+}
+
+func (t VersionsType) ValueFromTerraform(ctx context.Context, in tftypes.Value) (attr.Value, error) {
+	if in.Type() == nil {
+		return NewVersionsValueNull(), nil
+	}
+
+	if !in.Type().Equal(t.TerraformType(ctx)) {
+		return nil, fmt.Errorf("expected %s, got %s", t.TerraformType(ctx), in.Type())
+	}
+
+	if !in.IsKnown() {
+		return NewVersionsValueUnknown(), nil
+	}
+
+	if in.IsNull() {
+		return NewVersionsValueNull(), nil
+	}
+
+	attributes := map[string]attr.Value{}
+
+	val := map[string]tftypes.Value{}
+
+	err := in.As(&val)
+
+	if err != nil {
+		return nil, err
+	}
+
+	for k, v := range val {
+		a, err := t.AttrTypes[k].ValueFromTerraform(ctx, v)
+
+		if err != nil {
+			return nil, err
+		}
+
+		attributes[k] = a
+	}
+
+	return NewVersionsValueMust(VersionsValue{}.AttributeTypes(ctx), attributes), nil
+}
+
+func (t VersionsType) ValueType(ctx context.Context) attr.Value {
+	return VersionsValue{}
+}
+
+var _ basetypes.ObjectValuable = VersionsValue{}
+
+type VersionsValue struct {
+	Beta       basetypes.BoolValue   `tfsdk:"beta"`
+	Deprecated basetypes.StringValue `tfsdk:"deprecated"`
+	Recommend  basetypes.BoolValue   `tfsdk:"recommend"`
+	Version    basetypes.StringValue `tfsdk:"version"`
+	state      attr.ValueState
+}
+
+func (v VersionsValue) ToTerraformValue(ctx context.Context) (tftypes.Value, error) {
+	attrTypes := make(map[string]tftypes.Type, 4)
+
+	var val tftypes.Value
+	var err error
+
+	attrTypes["beta"] = basetypes.BoolType{}.TerraformType(ctx)
+	attrTypes["deprecated"] = basetypes.StringType{}.TerraformType(ctx)
+	attrTypes["recommend"] = basetypes.BoolType{}.TerraformType(ctx)
+	attrTypes["version"] = basetypes.StringType{}.TerraformType(ctx)
+
+	objectType := tftypes.Object{AttributeTypes: attrTypes}
+
+	switch v.state {
+	case attr.ValueStateKnown:
+		vals := make(map[string]tftypes.Value, 4)
+
+		val, err = v.Beta.ToTerraformValue(ctx)
+
+		if err != nil {
+			return tftypes.NewValue(objectType, tftypes.UnknownValue), err
+		}
+
+		vals["beta"] = val
+
+		val, err = v.Deprecated.ToTerraformValue(ctx)
+
+		if err != nil {
+			return tftypes.NewValue(objectType, tftypes.UnknownValue), err
+		}
+
+		vals["deprecated"] = val
+
+		val, err = v.Recommend.ToTerraformValue(ctx)
+
+		if err != nil {
+			return tftypes.NewValue(objectType, tftypes.UnknownValue), err
+		}
+
+		vals["recommend"] = val
+
+		val, err = v.Version.ToTerraformValue(ctx)
+
+		if err != nil {
+			return tftypes.NewValue(objectType, tftypes.UnknownValue), err
+		}
+
+		vals["version"] = val
+
+		if err := tftypes.ValidateValue(objectType, vals); err != nil {
+			return tftypes.NewValue(objectType, tftypes.UnknownValue), err
+		}
+
+		return tftypes.NewValue(objectType, vals), nil
+	case attr.ValueStateNull:
+		return tftypes.NewValue(objectType, nil), nil
+	case attr.ValueStateUnknown:
+		return tftypes.NewValue(objectType, tftypes.UnknownValue), nil
+	default:
+		panic(fmt.Sprintf("unhandled Object state in ToTerraformValue: %s", v.state))
+	}
+}
+
+func (v VersionsValue) IsNull() bool {
+	return v.state == attr.ValueStateNull
+}
+
+func (v VersionsValue) IsUnknown() bool {
+	return v.state == attr.ValueStateUnknown
+}
+
+func (v VersionsValue) String() string {
+	return "VersionsValue"
+}
+
+func (v VersionsValue) ToObjectValue(ctx context.Context) (basetypes.ObjectValue, diag.Diagnostics) {
+	var diags diag.Diagnostics
+
+	attributeTypes := map[string]attr.Type{
+		"beta":       basetypes.BoolType{},
+		"deprecated": basetypes.StringType{},
+		"recommend":  basetypes.BoolType{},
+		"version":    basetypes.StringType{},
+	}
+
+	if v.IsNull() {
+		return types.ObjectNull(attributeTypes), diags
+	}
+
+	if v.IsUnknown() {
+		return types.ObjectUnknown(attributeTypes), diags
+	}
+
+	objVal, diags := types.ObjectValue(
+		attributeTypes,
+		map[string]attr.Value{
+			"beta":       v.Beta,
+			"deprecated": v.Deprecated,
+			"recommend":  v.Recommend,
+			"version":    v.Version,
+		})
+
+	return objVal, diags
+}
+
+func (v VersionsValue) Equal(o attr.Value) bool {
+	other, ok := o.(VersionsValue)
+
+	if !ok {
+		return false
+	}
+
+	if v.state != other.state {
+		return false
+	}
+
+	if v.state != attr.ValueStateKnown {
+		return true
+	}
+
+	if !v.Beta.Equal(other.Beta) {
+		return false
+	}
+
+	if !v.Deprecated.Equal(other.Deprecated) {
+		return false
+	}
+
+	if !v.Recommend.Equal(other.Recommend) {
+		return false
+	}
+
+	if !v.Version.Equal(other.Version) {
+		return false
+	}
+
+	return true
+}
+
+func (v VersionsValue) Type(ctx context.Context) attr.Type {
+	return VersionsType{
+		basetypes.ObjectType{
+			AttrTypes: v.AttributeTypes(ctx),
+		},
+	}
+}
+
+func (v VersionsValue) AttributeTypes(ctx context.Context) map[string]attr.Type {
+	return map[string]attr.Type{
+		"beta":       basetypes.BoolType{},
+		"deprecated": basetypes.StringType{},
+		"recommend":  basetypes.BoolType{},
+		"version":    basetypes.StringType{},
+	}
+}

stackit/internal/services/sqlserverflexalpha/database/datasource.go

@@ -0,0 +1,175 @@
+package sqlserverflexalpha
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource"
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+	"github.com/hashicorp/terraform-plugin-framework/diag"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/hashicorp/terraform-plugin-log/tflog"
+	"github.com/stackitcloud/stackit-sdk-go/core/config"
+
+	"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"
+
+	sqlserverflexalphaPkg "github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3alpha1api"
+
+	sqlserverflexalphaGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/database/datasources_gen"
+)
+
+var _ datasource.DataSource = (*databaseDataSource)(nil)
+
+const errorPrefix = "[sqlserverflexalpha - Database]"
+
+func NewDatabaseDataSource() datasource.DataSource {
+	return &databaseDataSource{}
+}
+
+type dataSourceModel struct {
+	sqlserverflexalphaGen.DatabaseModel
+	TerraformId types.String `tfsdk:"id"`
+}
+
+type databaseDataSource struct {
+	client       *sqlserverflexalphaPkg.APIClient
+	providerData core.ProviderData
+}
+
+func (d *databaseDataSource) Metadata(
+	_ context.Context,
+	req datasource.MetadataRequest,
+	resp *datasource.MetadataResponse,
+) {
+	resp.TypeName = req.ProviderTypeName + "_sqlserverflexalpha_database"
+}
+
+func (d *databaseDataSource) Schema(ctx context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	resp.Schema = sqlserverflexalphaGen.DatabaseDataSourceSchema(ctx)
+	resp.Schema.Attributes["id"] = schema.StringAttribute{
+		Computed:            true,
+		Description:         "The terraform internal identifier.",
+		MarkdownDescription: "The terraform internal identifier.",
+	}
+}
+
+// Configure adds the provider configured client to the data source.
+func (d *databaseDataSource) Configure(
+	ctx context.Context,
+	req datasource.ConfigureRequest,
+	resp *datasource.ConfigureResponse,
+) {
+	var ok bool
+	d.providerData, ok = conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
+	if !ok {
+		return
+	}
+
+	apiClientConfigOptions := []config.ConfigurationOption{
+		config.WithCustomAuth(d.providerData.RoundTripper),
+		utils.UserAgentConfigOption(d.providerData.Version),
+	}
+	if d.providerData.SQLServerFlexCustomEndpoint != "" {
+		apiClientConfigOptions = append(
+			apiClientConfigOptions,
+			config.WithEndpoint(d.providerData.SQLServerFlexCustomEndpoint),
+		)
+	} else {
+		apiClientConfigOptions = append(
+			apiClientConfigOptions,
+			config.WithRegion(d.providerData.GetRegion()),
+		)
+	}
+	apiClient, err := sqlserverflexalphaPkg.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,
+			),
+		)
+		return
+	}
+	d.client = apiClient
+	tflog.Info(ctx, fmt.Sprintf("%s client configured", errorPrefix))
+}
+
+func (d *databaseDataSource) 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)...)
+
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	ctx = core.InitProviderContext(ctx)
+
+	// Extract identifiers from the plan
+	projectId := data.ProjectId.ValueString()
+	region := d.providerData.GetRegionWithOverride(data.Region)
+	instanceId := data.InstanceId.ValueString()
+
+	ctx = tflog.SetField(ctx, "project_id", projectId)
+	ctx = tflog.SetField(ctx, "region", region)
+	ctx = tflog.SetField(ctx, "instance_id", instanceId)
+
+	databaseName := data.DatabaseName.ValueString()
+
+	databaseResp, err := d.client.DefaultAPI.GetDatabaseRequest(ctx, projectId, region, instanceId, databaseName).Execute()
+	if err != nil {
+		handleReadError(ctx, &resp.Diagnostics, err, projectId, instanceId)
+		resp.State.RemoveResource(ctx)
+		return
+	}
+
+	ctx = core.LogResponse(ctx)
+	// Map response body to schema and populate Computed attribute values
+	err = mapFields(databaseResp, &data, region)
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"Error reading database",
+			fmt.Sprintf("Processing API payload: %v", err),
+		)
+		return
+	}
+
+	// Save data into Terraform state
+	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
+
+	tflog.Info(ctx, "SQL Server Flex Alpha database read")
+}
+
+// handleReadError centralizes API error handling for the Read operation.
+func handleReadError(ctx context.Context, diags *diag.Diagnostics, err error, projectId, instanceId string) {
+	utils.LogError(
+		ctx,
+		diags,
+		err,
+		"Reading database",
+		fmt.Sprintf(
+			"Could not retrieve database for instance %q in project %q.",
+			instanceId,
+			projectId,
+		),
+		map[int]string{
+			http.StatusBadRequest: fmt.Sprintf(
+				"Invalid request parameters for project %q and instance %q.",
+				projectId,
+				instanceId,
+			),
+			http.StatusNotFound: fmt.Sprintf(
+				"Database, instance %q, or project %q not found.",
+				instanceId,
+				projectId,
+			),
+			http.StatusForbidden: fmt.Sprintf("Forbidden access to project %q.", projectId),
+		},
+	)
+}

stackit/internal/services/sqlserverflexalpha/database/datasources_gen/database_data_source_gen.go

@@ -0,0 +1,81 @@
+// Code generated by terraform-plugin-framework-generator DO NOT EDIT.
+
+package sqlserverflexalpha
+
+import (
+	"context"
+	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
+	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+)
+
+func DatabaseDataSourceSchema(ctx context.Context) schema.Schema {
+	return schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"collation_name": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The collation of the database. This database collation should match the *collation_name* of one of the collations given by the **Get database collation list** endpoint.",
+				MarkdownDescription: "The collation of the database. This database collation should match the *collation_name* of one of the collations given by the **Get database collation list** endpoint.",
+			},
+			"compatibility_level": schema.Int64Attribute{
+				Computed:            true,
+				Description:         "CompatibilityLevel of the Database.",
+				MarkdownDescription: "CompatibilityLevel of the Database.",
+			},
+			"database_name": schema.StringAttribute{
+				Required:            true,
+				Description:         "The name of the database.",
+				MarkdownDescription: "The name of the database.",
+			},
+			"tf_original_api_id": schema.Int64Attribute{
+				Computed:            true,
+				Description:         "The id of the database.",
+				MarkdownDescription: "The id of the database.",
+			},
+			"instance_id": schema.StringAttribute{
+				Required:            true,
+				Description:         "The ID of the instance.",
+				MarkdownDescription: "The ID of the instance.",
+			},
+			"name": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The name of the database.",
+				MarkdownDescription: "The name of the database.",
+			},
+			"owner": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The owner of the database.",
+				MarkdownDescription: "The owner of the database.",
+			},
+			"project_id": schema.StringAttribute{
+				Required:            true,
+				Description:         "The STACKIT project ID.",
+				MarkdownDescription: "The STACKIT project ID.",
+			},
+			"region": schema.StringAttribute{
+				Required:            true,
+				Description:         "The region which should be addressed",
+				MarkdownDescription: "The region which should be addressed",
+				Validators: []validator.String{
+					stringvalidator.OneOf(
+						"eu01",
+					),
+				},
+			},
+		},
+	}
+}
+
+type DatabaseModel struct {
+	CollationName      types.String `tfsdk:"collation_name"`
+	CompatibilityLevel types.Int64  `tfsdk:"compatibility_level"`
+	DatabaseName       types.String `tfsdk:"database_name"`
+	Id                 types.Int64  `tfsdk:"tf_original_api_id"`
+	InstanceId         types.String `tfsdk:"instance_id"`
+	Name               types.String `tfsdk:"name"`
+	Owner              types.String `tfsdk:"owner"`
+	ProjectId          types.String `tfsdk:"project_id"`
+	Region             types.String `tfsdk:"region"`
+}

stackit/internal/services/sqlserverflexalpha/database/mapper.go

@@ -0,0 +1,106 @@
+package sqlserverflexalpha
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	coreUtils "github.com/stackitcloud/stackit-sdk-go/core/utils"
+
+	sqlserverflexalpha "github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3alpha1api"
+
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/utils"
+)
+
+// mapFields maps fields from a ListDatabase API response to a resourceModel for the data source.
+func mapFields(source *sqlserverflexalpha.GetDatabaseResponse, model *dataSourceModel, region string) error {
+	if source == nil {
+		return fmt.Errorf("response is nil")
+	}
+	if source.Id == 0 {
+		return fmt.Errorf("id not present")
+	}
+	if model == nil {
+		return fmt.Errorf("model given is nil")
+	}
+
+	var databaseId int64
+	if model.Id.ValueInt64() != 0 {
+		databaseId = model.Id.ValueInt64()
+	} else if source.Id != 0 {
+		databaseId = source.Id
+	} else {
+		return fmt.Errorf("database id not present")
+	}
+
+	model.Id = types.Int64Value(databaseId)
+	model.DatabaseName = types.StringValue(source.GetName())
+	model.Name = types.StringValue(source.GetName())
+	model.Owner = types.StringValue(strings.Trim(source.GetOwner(), "\""))
+	model.Region = types.StringValue(region)
+	model.ProjectId = types.StringValue(model.ProjectId.ValueString())
+	model.InstanceId = types.StringValue(model.InstanceId.ValueString())
+	model.CompatibilityLevel = types.Int64Value(int64(source.GetCompatibilityLevel()))
+	model.CollationName = types.StringValue(source.GetCollationName())
+
+	model.TerraformId = utils.BuildInternalTerraformId(
+		model.ProjectId.ValueString(),
+		region,
+		model.InstanceId.ValueString(),
+		model.DatabaseName.ValueString(),
+	)
+
+	return nil
+}
+
+// mapResourceFields maps fields from a ListDatabase API response to a resourceModel for the resource.
+func mapResourceFields(source *sqlserverflexalpha.GetDatabaseResponse, model *resourceModel, region string) error {
+	if source == nil {
+		return fmt.Errorf("response is nil")
+	}
+	if source.Id == 0 {
+		return fmt.Errorf("id not present")
+	}
+	if model == nil {
+		return fmt.Errorf("model input is nil")
+	}
+
+	var databaseId int64
+	if model.Id.ValueInt64() != 0 {
+		databaseId = model.Id.ValueInt64()
+	} else if source.Id != 0 {
+		databaseId = source.Id
+	} else {
+		return fmt.Errorf("database id not present")
+	}
+
+	model.Id = types.Int64Value(databaseId)
+	model.DatabaseName = types.StringValue(source.GetName())
+	model.Name = types.StringValue(source.GetName())
+	model.Owner = types.StringValue(strings.Trim(source.GetOwner(), "\""))
+	model.Region = types.StringValue(region)
+	model.ProjectId = types.StringValue(model.ProjectId.ValueString())
+	model.InstanceId = types.StringValue(model.InstanceId.ValueString())
+
+	model.Compatibility = types.Int64Value(int64(source.GetCompatibilityLevel()))
+	model.CompatibilityLevel = types.Int64Value(int64(source.GetCompatibilityLevel()))
+
+	model.Collation = types.StringValue(source.GetCollationName()) // it does not come back from api
+	model.CollationName = types.StringValue(source.GetCollationName())
+
+	return nil
+}
+
+// toCreatePayload converts the resource model to an API create payload.
+func toCreatePayload(model *resourceModel) (*sqlserverflexalpha.CreateDatabaseRequestPayload, error) {
+	if model == nil {
+		return nil, fmt.Errorf("nil model")
+	}
+
+	return &sqlserverflexalpha.CreateDatabaseRequestPayload{
+		Name:          model.Name.ValueString(),
+		Owner:         model.Owner.ValueString(),
+		Collation:     model.Collation.ValueStringPointer(),
+		Compatibility: coreUtils.Ptr(int32(model.Compatibility.ValueInt64())), //nolint:gosec // TODO
+	}, nil
+}

stackit/internal/services/sqlserverflexalpha/database/mapper_test.go

@@ -0,0 +1,233 @@
+package sqlserverflexalpha
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/stackitcloud/stackit-sdk-go/core/utils"
+	sqlserverflexalpha "github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3alpha1api"
+
+	datasource "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/database/datasources_gen"
+)
+
+func TestMapFields(t *testing.T) {
+	type given struct {
+		source *sqlserverflexalpha.GetDatabaseResponse
+		model  *dataSourceModel
+		region string
+	}
+	type expected struct {
+		model *dataSourceModel
+		err   bool
+	}
+
+	testcases := []struct {
+		name     string
+		given    given
+		expected expected
+	}{
+		{
+			name: "should map fields correctly",
+			given: given{
+				source: &sqlserverflexalpha.GetDatabaseResponse{
+					Id:                 (int64(1)),
+					Name:               ("my-db"),
+					CollationName:      ("collation"),
+					CompatibilityLevel: (int32(150)),
+					Owner:              ("my-owner"),
+				},
+				model: &dataSourceModel{
+					DatabaseModel: datasource.DatabaseModel{
+						ProjectId:  types.StringValue("my-project"),
+						InstanceId: types.StringValue("my-instance"),
+					},
+				},
+				region: "eu01",
+			},
+			expected: expected{
+				model: &dataSourceModel{
+					DatabaseModel: datasource.DatabaseModel{
+						Id:                 types.Int64Value(1),
+						Name:               types.StringValue("my-db"),
+						DatabaseName:       types.StringValue("my-db"),
+						Owner:              types.StringValue("my-owner"),
+						Region:             types.StringValue("eu01"),
+						InstanceId:         types.StringValue("my-instance"),
+						ProjectId:          types.StringValue("my-project"),
+						CompatibilityLevel: types.Int64Value(150),
+						CollationName:      types.StringValue("collation"),
+					},
+					TerraformId: types.StringValue("my-project,eu01,my-instance,my-db"),
+				},
+			},
+		},
+		{
+			name: "should fail on nil source",
+			given: given{
+				source: nil,
+				model:  &dataSourceModel{},
+			},
+			expected: expected{err: true},
+		},
+		{
+			name: "should fail on nil source ID",
+			given: given{
+				source: &sqlserverflexalpha.GetDatabaseResponse{Id: 0},
+				model:  &dataSourceModel{},
+			},
+			expected: expected{err: true},
+		},
+		{
+			name: "should fail on nil model",
+			given: given{
+				source: &sqlserverflexalpha.GetDatabaseResponse{Id: (int64(1))},
+				model:  nil,
+			},
+			expected: expected{err: true},
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(
+			tc.name, func(t *testing.T) {
+				err := mapFields(tc.given.source, tc.given.model, tc.given.region)
+				if (err != nil) != tc.expected.err {
+					t.Fatalf("expected error: %v, got: %v", tc.expected.err, err)
+				}
+				if err == nil {
+					if diff := cmp.Diff(tc.expected.model, tc.given.model); diff != "" {
+						t.Errorf("model mismatch (-want +got):\n%s", diff)
+					}
+				}
+			},
+		)
+	}
+}
+
+func TestMapResourceFields(t *testing.T) {
+	type given struct {
+		source *sqlserverflexalpha.GetDatabaseResponse
+		model  *resourceModel
+		region string
+	}
+	type expected struct {
+		model *resourceModel
+		err   bool
+	}
+
+	testcases := []struct {
+		name     string
+		given    given
+		expected expected
+	}{
+		{
+			name: "should map fields correctly",
+			given: given{
+				source: &sqlserverflexalpha.GetDatabaseResponse{
+					Id:    (int64(1)),
+					Name:  ("my-db"),
+					Owner: ("my-owner"),
+				},
+				model: &resourceModel{
+					ProjectId:  types.StringValue("my-project"),
+					InstanceId: types.StringValue("my-instance"),
+				},
+				region: "eu01",
+			},
+			expected: expected{
+				model: &resourceModel{
+					Id:                 types.Int64Value(1),
+					Name:               types.StringValue("my-db"),
+					Compatibility:      types.Int64Value(0),
+					CompatibilityLevel: types.Int64Value(0),
+					Collation:          types.StringValue(""),
+					CollationName:      types.StringValue(""),
+					DatabaseName:       types.StringValue("my-db"),
+					InstanceId:         types.StringValue("my-instance"),
+					ProjectId:          types.StringValue("my-project"),
+					Region:             types.StringValue("eu01"),
+					Owner:              types.StringValue("my-owner"),
+				},
+			},
+		},
+		{
+			name: "should fail on nil source",
+			given: given{
+				source: nil,
+				model:  &resourceModel{},
+			},
+			expected: expected{err: true},
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(
+			tc.name, func(t *testing.T) {
+				err := mapResourceFields(tc.given.source, tc.given.model, tc.given.region)
+				if (err != nil) != tc.expected.err {
+					t.Fatalf("expected error: %v, got: %v", tc.expected.err, err)
+				}
+				if err == nil {
+					if diff := cmp.Diff(tc.expected.model, tc.given.model); diff != "" {
+						t.Errorf("model mismatch (-want +got):\n%s", diff)
+					}
+				}
+			},
+		)
+	}
+}
+
+func TestToCreatePayload(t *testing.T) {
+	type given struct {
+		model *resourceModel
+	}
+	type expected struct {
+		payload *sqlserverflexalpha.CreateDatabaseRequestPayload
+		err     bool
+	}
+
+	testcases := []struct {
+		name     string
+		given    given
+		expected expected
+	}{
+		{
+			name: "should convert model to payload",
+			given: given{
+				model: &resourceModel{
+					Name:  types.StringValue("my-db"),
+					Owner: types.StringValue("my-owner"),
+				},
+			},
+			expected: expected{
+				payload: &sqlserverflexalpha.CreateDatabaseRequestPayload{
+					Name:          "my-db",
+					Owner:         "my-owner",
+					Compatibility: utils.Ptr(int32(0)),
+				},
+			},
+		},
+		{
+			name:     "should fail on nil model",
+			given:    given{model: nil},
+			expected: expected{err: true},
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(
+			tc.name, func(t *testing.T) {
+				actual, err := toCreatePayload(tc.given.model)
+				if (err != nil) != tc.expected.err {
+					t.Fatalf("expected error: %v, got: %v", tc.expected.err, err)
+				}
+				if err == nil {
+					if diff := cmp.Diff(tc.expected.payload, actual); diff != "" {
+						t.Errorf("payload mismatch (-want +got):\n%s", diff)
+					}
+				}
+			},
+		)
+	}
+}

stackit/internal/services/sqlserverflexalpha/database/planModifiers.yaml

@@ -0,0 +1,51 @@
+fields:
+  - name: 'id'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'instance_id'
+    validators:
+      - validate.NoSeparator
+      - validate.UUID
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'project_id'
+    validators:
+      - validate.NoSeparator
+      - validate.UUID
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'region'
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'name'
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'collation'
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'owner'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'database_name'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'collation_name'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'compatibility'
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+  
+  - name: 'compatibility_level'
+    modifiers:
+      - 'UseStateForUnknown'

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

@@ -0,0 +1,541 @@
+package sqlserverflexalpha
+
+import (
+	"context"
+	_ "embed"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/hashicorp/terraform-plugin-framework/path"
+	"github.com/hashicorp/terraform-plugin-framework/resource"
+	"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"
+	coreUtils "github.com/stackitcloud/stackit-sdk-go/core/utils"
+
+	sqlserverflexalpha "github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3alpha1api"
+
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/conversion"
+	wait "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/database/resources_gen"
+)
+
+var (
+	_ resource.Resource                = &databaseResource{}
+	_ resource.ResourceWithConfigure   = &databaseResource{}
+	_ resource.ResourceWithImportState = &databaseResource{}
+	_ resource.ResourceWithModifyPlan  = &databaseResource{}
+	_ resource.ResourceWithIdentity    = &databaseResource{}
+
+	// Define errors
+	errDatabaseNotFound = errors.New("database not found")
+)
+
+func NewDatabaseResource() resource.Resource {
+	return &databaseResource{}
+}
+
+// resourceModel describes the resource data model.
+type resourceModel = sqlserverflexalphaResGen.DatabaseModel
+
+type databaseResource struct {
+	client       *sqlserverflexalpha.APIClient
+	providerData core.ProviderData
+}
+
+type DatabaseResourceIdentityModel struct {
+	ProjectID    types.String `tfsdk:"project_id"`
+	Region       types.String `tfsdk:"region"`
+	InstanceID   types.String `tfsdk:"instance_id"`
+	DatabaseName types.String `tfsdk:"database_name"`
+}
+
+func (r *databaseResource) Metadata(
+	_ context.Context,
+	req resource.MetadataRequest,
+	resp *resource.MetadataResponse,
+) {
+	resp.TypeName = req.ProviderTypeName + "_sqlserverflexalpha_database"
+}
+
+//go:embed planModifiers.yaml
+var modifiersFileByte []byte
+
+func (r *databaseResource) Schema(ctx context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
+	s := sqlserverflexalphaResGen.DatabaseResourceSchema(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 *databaseResource) 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
+			},
+			"database_name": identityschema.StringAttribute{
+				RequiredForImport: true, // can be defaulted by the provider configuration
+			},
+		},
+	}
+}
+
+// Configure adds the provider configured client to the resource.
+func (r *databaseResource) 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 := sqlserverflexalpha.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,
+			),
+		)
+		return
+	}
+	r.client = apiClient
+	tflog.Info(ctx, "sqlserverflexalpha.Database client configured")
+}
+
+func (r *databaseResource) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) {
+	var data resourceModel
+	createErr := "DB create error"
+
+	// Read Terraform plan data into the model
+	resp.Diagnostics.Append(req.Plan.Get(ctx, &data)...)
+
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	ctx = core.InitProviderContext(ctx)
+
+	projectId := data.ProjectId.ValueString()
+	region := data.Region.ValueString()
+	instanceId := data.InstanceId.ValueString()
+	ctx = tflog.SetField(ctx, "project_id", projectId)
+	ctx = tflog.SetField(ctx, "region", region)
+	ctx = tflog.SetField(ctx, "instance_id", instanceId)
+
+	databaseName := data.Name.ValueString()
+	ctx = tflog.SetField(ctx, "database_name", databaseName)
+
+	payLoad := sqlserverflexalpha.CreateDatabaseRequestPayload{}
+	if !data.Collation.IsNull() && !data.Collation.IsUnknown() {
+		payLoad.Collation = data.Collation.ValueStringPointer()
+	}
+
+	if !data.Compatibility.IsNull() && !data.Compatibility.IsUnknown() {
+		payLoad.Compatibility = coreUtils.Ptr(int32(data.Compatibility.ValueInt64())) //nolint:gosec // TODO
+	}
+
+	payLoad.Name = data.Name.ValueString()
+	payLoad.Owner = data.Owner.ValueString()
+
+	createResp, err := r.client.DefaultAPI.CreateDatabaseRequest(ctx, projectId, region, instanceId).
+		CreateDatabaseRequestPayload(payLoad).
+		Execute()
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			createErr,
+			fmt.Sprintf("Calling API: %v", err),
+		)
+		return
+	}
+
+	if createResp == nil || createResp.Id == 0 {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"Error creating database",
+			"API didn't return database Id. A database might have been created",
+		)
+		return
+	}
+
+	databaseId := createResp.Id
+
+	ctx = tflog.SetField(ctx, "database_id", databaseId)
+
+	ctx = core.LogResponse(ctx)
+
+	// Set data returned by API in identity
+	identity := DatabaseResourceIdentityModel{
+		ProjectID:    types.StringValue(projectId),
+		Region:       types.StringValue(region),
+		InstanceID:   types.StringValue(instanceId),
+		DatabaseName: types.StringValue(databaseName),
+	}
+	resp.Diagnostics.Append(resp.Identity.Set(ctx, identity)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	// TODO: is this necessary to wait for the database-> API say 200 ?
+	waitResp, err := wait.CreateDatabaseWaitHandler(
+		ctx,
+		r.client.DefaultAPI,
+		projectId,
+		instanceId,
+		region,
+		databaseName,
+	).SetSleepBeforeWait(
+		30 * time.Second,
+	).SetTimeout(
+		15 * time.Minute,
+	).WaitWithContext(ctx)
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			createErr,
+			fmt.Sprintf("Database creation waiting: %v", err),
+		)
+		return
+	}
+
+	if waitResp.Id == 0 {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			createErr,
+			"Database creation waiting: returned id is nil",
+		)
+		return
+	}
+
+	if waitResp.Id != databaseId {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			createErr,
+			"Database creation waiting: returned id is different",
+		)
+		return
+	}
+
+	if waitResp.Owner != data.Owner.ValueString() {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			createErr,
+			"Database creation waiting: returned owner is different",
+		)
+		return
+	}
+
+	if waitResp.Name != data.Name.ValueString() {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			createErr,
+			"Database creation waiting: returned name is different",
+		)
+		return
+	}
+
+	database, err := r.client.DefaultAPI.GetDatabaseRequest(ctx, projectId, region, instanceId, databaseName).Execute()
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"Error creating database",
+			fmt.Sprintf("Getting database details after creation: %v", err),
+		)
+		return
+	}
+
+	// Map response body to schema
+	err = mapResourceFields(database, &data, region)
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"Error creating database",
+			fmt.Sprintf("Processing API payload: %v", err),
+		)
+		return
+	}
+
+	// Set state to fully populated data
+	resp.Diagnostics.Append(resp.State.Set(ctx, data)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	// Save data into Terraform state
+
+	tflog.Info(ctx, "sqlserverflexalpha.Database created")
+}
+
+func (r *databaseResource) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse) {
+	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()
+	region := model.Region.ValueString()
+	instanceId := model.InstanceId.ValueString()
+	databaseName := model.DatabaseName.ValueString()
+
+	ctx = tflog.SetField(ctx, "project_id", projectId)
+	ctx = tflog.SetField(ctx, "instance_id", instanceId)
+	ctx = tflog.SetField(ctx, "region", region)
+	ctx = tflog.SetField(ctx, "database_name", databaseName)
+
+	databaseResp, err := r.client.DefaultAPI.GetDatabaseRequest(ctx, projectId, region, instanceId, databaseName).Execute()
+	if err != nil {
+		oapiErr, ok := err.(*oapierror.GenericOpenAPIError) //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) || errors.Is(err, errDatabaseNotFound) {
+			resp.State.RemoveResource(ctx)
+			return
+		}
+		core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading database", fmt.Sprintf("Calling API: %v", err))
+		return
+	}
+
+	ctx = core.LogResponse(ctx)
+
+	// Map response body to schema
+	err = mapResourceFields(databaseResp, &model, region)
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"Error reading database",
+			fmt.Sprintf("Processing API payload: %v", err),
+		)
+		return
+	}
+
+	// Save identity into Terraform state
+	identity := DatabaseResourceIdentityModel{
+		ProjectID:    types.StringValue(projectId),
+		Region:       types.StringValue(region),
+		InstanceID:   types.StringValue(instanceId),
+		DatabaseName: types.StringValue(databaseName),
+	}
+	resp.Diagnostics.Append(resp.Identity.Set(ctx, identity)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	// Set refreshed state
+	resp.Diagnostics.Append(resp.State.Set(ctx, &model)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	tflog.Info(ctx, "sqlserverflexalpha.Database read")
+}
+
+func (r *databaseResource) Update(ctx context.Context, _ resource.UpdateRequest, resp *resource.UpdateResponse) {
+	// TODO: Check update api endpoint - not available at the moment, so return an error for now
+	core.LogAndAddError(ctx, &resp.Diagnostics, "Error updating database", "Database can't be updated")
+}
+
+func (r *databaseResource) Delete(ctx context.Context, req resource.DeleteRequest, resp *resource.DeleteResponse) {
+	// 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
+	}
+
+	// Read identity data
+	var identityData DatabaseResourceIdentityModel
+	resp.Diagnostics.Append(req.Identity.Get(ctx, &identityData)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	ctx = core.InitProviderContext(ctx)
+
+	projectId := model.ProjectId.ValueString()
+	region := model.Region.ValueString()
+	instanceId := model.InstanceId.ValueString()
+	databaseName := model.DatabaseName.ValueString()
+
+	ctx = tflog.SetField(ctx, "project_id", projectId)
+	ctx = tflog.SetField(ctx, "instance_id", instanceId)
+	ctx = tflog.SetField(ctx, "region", region)
+	ctx = tflog.SetField(ctx, "database_name", databaseName)
+
+	// Delete existing record set
+	err := r.client.DefaultAPI.DeleteDatabaseRequest(ctx, projectId, region, instanceId, databaseName).Execute()
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"Error deleting database",
+			fmt.Sprintf(
+				"Calling API: %v\nname: %s, region: %s, instanceId: %s", err, databaseName, region, instanceId,
+			),
+		)
+		return
+	}
+
+	ctx = core.LogResponse(ctx)
+	resp.State.RemoveResource(ctx)
+
+	tflog.Info(ctx, "sqlserverflexalpha.Database deleted")
+}
+
+// ModifyPlan implements resource.ResourceWithModifyPlan.
+// Use the modifier to set the effective region in the current plan.
+func (r *databaseResource) ModifyPlan(
+	ctx context.Context,
+	req resource.ModifyPlanRequest,
+	resp *resource.ModifyPlanResponse,
+) { // nolint:gocritic // function signature required by Terraform
+	// skip initial empty configuration to avoid follow-up errors
+	if req.Config.Raw.IsNull() {
+		return
+	}
+
+	var configModel resourceModel
+	resp.Diagnostics.Append(req.Config.Get(ctx, &configModel)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	var planModel resourceModel
+	resp.Diagnostics.Append(req.Plan.Get(ctx, &planModel)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	utils.AdaptRegion(ctx, configModel.Region, &planModel.Region, r.providerData.GetRegion(), resp)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	resp.Diagnostics.Append(resp.Plan.Set(ctx, planModel)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+}
+
+// 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 *databaseResource) ImportState(
+	ctx context.Context,
+	req resource.ImportStateRequest,
+	resp *resource.ImportStateResponse,
+) {
+	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 database",
+				fmt.Sprintf(
+					"Expected import identifier with format [project_id],[region],[instance_id],[database_name]  Got: %q",
+					req.ID,
+				),
+			)
+			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("database_name"), idParts[3])...)
+
+		var identityData DatabaseResourceIdentityModel
+		identityData.ProjectID = types.StringValue(idParts[0])
+		identityData.Region = types.StringValue(idParts[1])
+		identityData.InstanceID = types.StringValue(idParts[2])
+		identityData.DatabaseName = types.StringValue(idParts[3])
+
+		resp.Diagnostics.Append(resp.Identity.Set(ctx, &identityData)...)
+		if resp.Diagnostics.HasError() {
+			return
+		}
+
+		tflog.Info(ctx, "sqlserverflexalpha database state imported")
+		return
+	}
+
+	// If no ID is provided, attempt to read identity attributes from the import configuration
+	var identityData DatabaseResourceIdentityModel
+	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()
+	databaseName := identityData.DatabaseName.ValueString()
+
+	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("database_name"), databaseName)...)
+
+	tflog.Info(ctx, "sqlserverflexalpha database state imported")
+}

stackit/internal/services/sqlserverflexalpha/database/resources_gen/database_resource_gen.go

@@ -0,0 +1,99 @@
+// Code generated by terraform-plugin-framework-generator DO NOT EDIT.
+
+package sqlserverflexalpha
+
+import (
+	"context"
+	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
+	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema"
+)
+
+func DatabaseResourceSchema(ctx context.Context) schema.Schema {
+	return schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"collation": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The collation of the database. This database collation should match the *collation_name* of one of the collations given by the **Get database collation list** endpoint.",
+				MarkdownDescription: "The collation of the database. This database collation should match the *collation_name* of one of the collations given by the **Get database collation list** endpoint.",
+			},
+			"collation_name": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The collation of the database. This database collation should match the *collation_name* of one of the collations given by the **Get database collation list** endpoint.",
+				MarkdownDescription: "The collation of the database. This database collation should match the *collation_name* of one of the collations given by the **Get database collation list** endpoint.",
+			},
+			"compatibility": schema.Int64Attribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "CompatibilityLevel of the Database.",
+				MarkdownDescription: "CompatibilityLevel of the Database.",
+			},
+			"compatibility_level": schema.Int64Attribute{
+				Computed:            true,
+				Description:         "CompatibilityLevel of the Database.",
+				MarkdownDescription: "CompatibilityLevel of the Database.",
+			},
+			"database_name": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The name of the database.",
+				MarkdownDescription: "The name of the database.",
+			},
+			"id": schema.Int64Attribute{
+				Computed:            true,
+				Description:         "The id of the database.",
+				MarkdownDescription: "The id of the database.",
+			},
+			"instance_id": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The ID of the instance.",
+				MarkdownDescription: "The ID of the instance.",
+			},
+			"name": schema.StringAttribute{
+				Required:            true,
+				Description:         "The name of the database.",
+				MarkdownDescription: "The name of the database.",
+			},
+			"owner": schema.StringAttribute{
+				Required:            true,
+				Description:         "The owner of the database.",
+				MarkdownDescription: "The owner of the database.",
+			},
+			"project_id": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The STACKIT project ID.",
+				MarkdownDescription: "The STACKIT project ID.",
+			},
+			"region": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The region which should be addressed",
+				MarkdownDescription: "The region which should be addressed",
+				Validators: []validator.String{
+					stringvalidator.OneOf(
+						"eu01",
+					),
+				},
+			},
+		},
+	}
+}
+
+type DatabaseModel struct {
+	Collation          types.String `tfsdk:"collation"`
+	CollationName      types.String `tfsdk:"collation_name"`
+	Compatibility      types.Int64  `tfsdk:"compatibility"`
+	CompatibilityLevel types.Int64  `tfsdk:"compatibility_level"`
+	DatabaseName       types.String `tfsdk:"database_name"`
+	Id                 types.Int64  `tfsdk:"id"`
+	InstanceId         types.String `tfsdk:"instance_id"`
+	Name               types.String `tfsdk:"name"`
+	Owner              types.String `tfsdk:"owner"`
+	ProjectId          types.String `tfsdk:"project_id"`
+	Region             types.String `tfsdk:"region"`
+}

stackit/internal/services/sqlserverflexalpha/flavor/datasource.go

@@ -0,0 +1,356 @@
+package sqlserverflexalphaFlavor
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-framework/attr"
+	"github.com/hashicorp/terraform-plugin-framework/datasource"
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
+	"github.com/hashicorp/terraform-plugin-log/tflog"
+	"github.com/stackitcloud/stackit-sdk-go/core/config"
+
+	"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"
+
+	sqlserverflexalphaPkg "github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3alpha1api"
+
+	sqlserverflexalphaGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/flavor/datasources_gen"
+)
+
+// Ensure the implementation satisfies the expected interfaces.
+var (
+	_ datasource.DataSource              = &flavorDataSource{}
+	_ datasource.DataSourceWithConfigure = &flavorDataSource{}
+)
+
+type FlavorModel struct {
+	ProjectId      types.String `tfsdk:"project_id"`
+	Region         types.String `tfsdk:"region"`
+	StorageClass   types.String `tfsdk:"storage_class"`
+	Cpu            types.Int64  `tfsdk:"cpu"`
+	Description    types.String `tfsdk:"description"`
+	Id             types.String `tfsdk:"id"`
+	FlavorId       types.String `tfsdk:"flavor_id"`
+	MaxGb          types.Int64  `tfsdk:"max_gb"`
+	Memory         types.Int64  `tfsdk:"ram"`
+	MinGb          types.Int64  `tfsdk:"min_gb"`
+	NodeType       types.String `tfsdk:"node_type"`
+	StorageClasses types.List   `tfsdk:"storage_classes"`
+}
+
+// NewFlavorDataSource is a helper function to simplify the provider implementation.
+func NewFlavorDataSource() datasource.DataSource {
+	return &flavorDataSource{}
+}
+
+// flavorDataSource is the data source implementation.
+type flavorDataSource struct {
+	client       *sqlserverflexalphaPkg.APIClient
+	providerData core.ProviderData
+}
+
+// Metadata returns the data source type name.
+func (r *flavorDataSource) Metadata(_ context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {
+	resp.TypeName = req.ProviderTypeName + "_sqlserverflexalpha_flavor"
+}
+
+// Configure adds the provider configured client to the data source.
+func (r *flavorDataSource) Configure(ctx context.Context, req datasource.ConfigureRequest, resp *datasource.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 := sqlserverflexalphaPkg.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,
+			),
+		)
+		return
+	}
+	r.client = apiClient
+	tflog.Info(ctx, "SQL Server Flex instance client configured")
+}
+
+func (r *flavorDataSource) Schema(ctx context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	resp.Schema = schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"project_id": schema.StringAttribute{
+				Required:            true,
+				Description:         "The project ID of the flavor.",
+				MarkdownDescription: "The project ID of the flavor.",
+			},
+			"region": schema.StringAttribute{
+				Required:            true,
+				Description:         "The region of the flavor.",
+				MarkdownDescription: "The region of the flavor.",
+			},
+			"cpu": schema.Int64Attribute{
+				Required:            true,
+				Description:         "The cpu count of the instance.",
+				MarkdownDescription: "The cpu count of the instance.",
+			},
+			"ram": schema.Int64Attribute{
+				Required:            true,
+				Description:         "The memory of the instance in Gibibyte.",
+				MarkdownDescription: "The memory of the instance in Gibibyte.",
+			},
+			"storage_class": schema.StringAttribute{
+				Required:            true,
+				Description:         "The memory of the instance in Gibibyte.",
+				MarkdownDescription: "The memory of the instance in Gibibyte.",
+			},
+			"node_type": schema.StringAttribute{
+				Required:            true,
+				Description:         "defines the nodeType it can be either single or HA",
+				MarkdownDescription: "defines the nodeType it can be either single or HA",
+			},
+			"flavor_id": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The id of the instance flavor.",
+				MarkdownDescription: "The id of the instance flavor.",
+			},
+			"description": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The flavor description.",
+				MarkdownDescription: "The flavor description.",
+			},
+			"id": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The id of the instance flavor.",
+				MarkdownDescription: "The id of the instance flavor.",
+			},
+			"max_gb": schema.Int64Attribute{
+				Computed:            true,
+				Description:         "maximum storage which can be ordered for the flavor in Gigabyte.",
+				MarkdownDescription: "maximum storage which can be ordered for the flavor in Gigabyte.",
+			},
+			"min_gb": schema.Int64Attribute{
+				Computed:            true,
+				Description:         "minimum storage which is required to order in Gigabyte.",
+				MarkdownDescription: "minimum storage which is required to order in Gigabyte.",
+			},
+			"storage_classes": schema.ListNestedAttribute{
+				NestedObject: schema.NestedAttributeObject{
+					Attributes: map[string]schema.Attribute{
+						"class": schema.StringAttribute{
+							Computed: true,
+						},
+						"max_io_per_sec": schema.Int64Attribute{
+							Computed: true,
+						},
+						"max_through_in_mb": schema.Int64Attribute{
+							Computed: true,
+						},
+					},
+					CustomType: sqlserverflexalphaGen.StorageClassesType{
+						ObjectType: types.ObjectType{
+							AttrTypes: sqlserverflexalphaGen.StorageClassesValue{}.AttributeTypes(ctx),
+						},
+					},
+				},
+				Computed:            true,
+				Description:         "maximum storage which can be ordered for the flavor in Gigabyte.",
+				MarkdownDescription: "maximum storage which can be ordered for the flavor in Gigabyte.",
+			},
+		},
+		//Attributes: map[string]schema.Attribute{
+		//	"project_id": schema.StringAttribute{
+		//		Required:            true,
+		//		Description:         "The cpu count of the instance.",
+		//		MarkdownDescription: "The cpu count of the instance.",
+		//	},
+		//	"region": schema.StringAttribute{
+		//		Required:            true,
+		//		Description:         "The flavor description.",
+		//		MarkdownDescription: "The flavor description.",
+		//	},
+		//	"cpu": schema.Int64Attribute{
+		//		Required:            true,
+		//		Description:         "The cpu count of the instance.",
+		//		MarkdownDescription: "The cpu count of the instance.",
+		//	},
+		//	"ram": schema.Int64Attribute{
+		//		Required:            true,
+		//		Description:         "The memory of the instance in Gibibyte.",
+		//		MarkdownDescription: "The memory of the instance in Gibibyte.",
+		//	},
+		//	"storage_class": schema.StringAttribute{
+		//		Required:            true,
+		//		Description:         "The memory of the instance in Gibibyte.",
+		//		MarkdownDescription: "The memory of the instance in Gibibyte.",
+		//	},
+		//	"description": schema.StringAttribute{
+		//		Computed:            true,
+		//		Description:         "The flavor description.",
+		//		MarkdownDescription: "The flavor description.",
+		//	},
+		//	"id": schema.StringAttribute{
+		//		Computed:            true,
+		//		Description:         "The terraform id of the instance flavor.",
+		//		MarkdownDescription: "The terraform id of the instance flavor.",
+		//	},
+		//	"flavor_id": schema.StringAttribute{
+		//		Computed:            true,
+		//		Description:         "The flavor id of the instance flavor.",
+		//		MarkdownDescription: "The flavor id of the instance flavor.",
+		//	},
+		//	"max_gb": schema.Int64Attribute{
+		//		Computed:            true,
+		//		Description:         "maximum storage which can be ordered for the flavor in Gigabyte.",
+		//		MarkdownDescription: "maximum storage which can be ordered for the flavor in Gigabyte.",
+		//	},
+		//	"min_gb": schema.Int64Attribute{
+		//		Computed:            true,
+		//		Description:         "minimum storage which is required to order in Gigabyte.",
+		//		MarkdownDescription: "minimum storage which is required to order in Gigabyte.",
+		//	},
+		//	"node_type": schema.StringAttribute{
+		//		Required:            true,
+		//		Description:         "defines the nodeType it can be either single or replica",
+		//		MarkdownDescription: "defines the nodeType it can be either single or replica",
+		//	},
+		//	"storage_classes": schema.ListNestedAttribute{
+		//		Computed: true,
+		//		NestedObject: schema.NestedAttributeObject{
+		//			Attributes: map[string]schema.Attribute{
+		//				"class": schema.StringAttribute{
+		//					Computed: true,
+		//				},
+		//				"max_io_per_sec": schema.Int64Attribute{
+		//					Computed: true,
+		//				},
+		//				"max_through_in_mb": schema.Int64Attribute{
+		//					Computed: true,
+		//				},
+		//			},
+		//			CustomType: sqlserverflexalphaGen.StorageClassesType{
+		//				ObjectType: types.ObjectType{
+		//					AttrTypes: sqlserverflexalphaGen.StorageClassesValue{}.AttributeTypes(ctx),
+		//				},
+		//			},
+		//		},
+		//	},
+		// },
+	}
+}
+
+func (r *flavorDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) {
+	var model FlavorModel
+	diags := req.Config.Get(ctx, &model)
+	resp.Diagnostics.Append(diags...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	ctx = core.InitProviderContext(ctx)
+
+	projectId := model.ProjectId.ValueString()
+	region := r.providerData.GetRegionWithOverride(model.Region)
+	ctx = tflog.SetField(ctx, "project_id", projectId)
+	ctx = tflog.SetField(ctx, "region", region)
+
+	flavors, err := getAllFlavors(ctx, r.client.DefaultAPI, projectId, region)
+	if err != nil {
+		core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading flavors", fmt.Sprintf("getAllFlavors: %v", err))
+		return
+	}
+
+	var foundFlavors []sqlserverflexalphaPkg.ListFlavors
+	for _, flavor := range flavors {
+		if model.Cpu.ValueInt64() != flavor.Cpu {
+			continue
+		}
+		if model.Memory.ValueInt64() != flavor.Memory {
+			continue
+		}
+		if model.NodeType.ValueString() != flavor.NodeType {
+			continue
+		}
+		for _, sc := range flavor.StorageClasses {
+			if model.StorageClass.ValueString() != sc.Class {
+				continue
+			}
+			foundFlavors = append(foundFlavors, flavor)
+		}
+	}
+	if len(foundFlavors) == 0 {
+		resp.Diagnostics.AddError("get flavor", "could not find requested flavor")
+		return
+	}
+	if len(foundFlavors) > 1 {
+		resp.Diagnostics.AddError("get flavor", "found too many matching flavors")
+		return
+	}
+
+	f := foundFlavors[0]
+	model.Description = types.StringValue(f.Description)
+	model.Id = utils.BuildInternalTerraformId(model.ProjectId.ValueString(), region, f.Id)
+	model.FlavorId = types.StringValue(f.Id)
+	model.MaxGb = types.Int64Value(int64(f.MaxGB))
+	model.MinGb = types.Int64Value(int64(f.MinGB))
+
+	if f.StorageClasses == nil {
+		model.StorageClasses = types.ListNull(sqlserverflexalphaGen.StorageClassesType{
+			ObjectType: basetypes.ObjectType{
+				AttrTypes: sqlserverflexalphaGen.StorageClassesValue{}.AttributeTypes(ctx),
+			},
+		})
+	} else {
+		var scList []attr.Value
+		for _, sc := range f.StorageClasses {
+			scList = append(
+				scList,
+				sqlserverflexalphaGen.NewStorageClassesValueMust(
+					sqlserverflexalphaGen.StorageClassesValue{}.AttributeTypes(ctx),
+					map[string]attr.Value{
+						"class":             types.StringValue(sc.Class),
+						"max_io_per_sec":    types.Int64Value(int64(sc.MaxIoPerSec)),
+						"max_through_in_mb": types.Int64Value(int64(sc.MaxThroughInMb)),
+					},
+				),
+			)
+		}
+		storageClassesList := types.ListValueMust(
+			sqlserverflexalphaGen.StorageClassesType{
+				ObjectType: basetypes.ObjectType{
+					AttrTypes: sqlserverflexalphaGen.StorageClassesValue{}.AttributeTypes(ctx),
+				},
+			},
+			scList,
+		)
+		model.StorageClasses = storageClassesList
+	}
+
+	// Set refreshed state
+	diags = resp.State.Set(ctx, model)
+	resp.Diagnostics.Append(diags...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	tflog.Info(ctx, "SQL Server Flex flavors read")
+}

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

@@ -0,0 +1,65 @@
+package sqlserverflexalphaFlavor
+
+import (
+	"context"
+	"fmt"
+
+	sqlserverflexalpha "github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3alpha1api"
+)
+
+type flavorsClientReader interface {
+	GetFlavorsRequest(
+		ctx context.Context,
+		projectId, region string,
+	) sqlserverflexalpha.ApiGetFlavorsRequestRequest
+}
+
+func getAllFlavors(ctx context.Context, client flavorsClientReader, projectId, region string) (
+	[]sqlserverflexalpha.ListFlavors,
+	error,
+) {
+	getAllFilter := func(_ sqlserverflexalpha.ListFlavors) bool { return true }
+	flavorList, err := getFlavorsByFilter(ctx, client, projectId, region, getAllFilter)
+	if err != nil {
+		return nil, err
+	}
+	return flavorList, nil
+}
+
+// getFlavorsByFilter is a helper function to retrieve flavors using a filtern function.
+// Hint: The API does not have a GetFlavors endpoint, only ListFlavors
+func getFlavorsByFilter(
+	ctx context.Context,
+	client flavorsClientReader,
+	projectId, region string,
+	filter func(db sqlserverflexalpha.ListFlavors) bool,
+) ([]sqlserverflexalpha.ListFlavors, error) {
+	if projectId == "" || region == "" {
+		return nil, fmt.Errorf("listing sqlserverflexalpha flavors: projectId and region are required")
+	}
+
+	const pageSize = 25
+
+	var result = make([]sqlserverflexalpha.ListFlavors, 0)
+
+	for page := int64(1); ; page++ {
+		res, err := client.GetFlavorsRequest(ctx, projectId, region).
+			Page(page).Size(pageSize).Sort(sqlserverflexalpha.FLAVORSORT_INDEX_ASC).Execute()
+		if err != nil {
+			return nil, fmt.Errorf("requesting flavors list (page %d): %w", page, err)
+		}
+
+		// If the API returns no flavors, we have reached the end of the list.
+		if len(res.Flavors) == 0 {
+			break
+		}
+
+		for _, flavor := range res.Flavors {
+			if filter(flavor) {
+				result = append(result, flavor)
+			}
+		}
+	}
+
+	return result, nil
+}

stackit/internal/services/sqlserverflexalpha/flavor/functions_test.go

@@ -0,0 +1,109 @@
+package sqlserverflexalphaFlavor
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3alpha1api"
+)
+
+var mockResp = func(page int64) (*v3alpha1api.GetFlavorsResponse, error) {
+	if page == 1 {
+		return &v3alpha1api.GetFlavorsResponse{
+			Flavors: []v3alpha1api.ListFlavors{
+				{Id: "flavor-1", Description: "first"},
+				{Id: "flavor-2", Description: "second"},
+			},
+		}, nil
+	}
+	if page == 2 {
+		return &v3alpha1api.GetFlavorsResponse{
+			Flavors: []v3alpha1api.ListFlavors{
+				{Id: "flavor-3", Description: "three"},
+			},
+		}, nil
+	}
+
+	return &v3alpha1api.GetFlavorsResponse{
+		Flavors: []v3alpha1api.ListFlavors{},
+	}, nil
+}
+
+func TestGetFlavorsByFilter(t *testing.T) {
+	tests := []struct {
+		description string
+		projectID   string
+		region      string
+		mockErr     error
+		filter      func(v3alpha1api.ListFlavors) bool
+		wantCount   int
+		wantErr     bool
+	}{
+		{
+			description: "Success - Get all flavors (2 pages)",
+			projectID:   "pid", region: "reg",
+			filter:    func(_ v3alpha1api.ListFlavors) bool { return true },
+			wantCount: 3,
+			wantErr:   false,
+		},
+		{
+			description: "Success - Filter flavors by description",
+			projectID:   "pid", region: "reg",
+			filter:    func(f v3alpha1api.ListFlavors) bool { return f.Description == "first" },
+			wantCount: 1,
+			wantErr:   false,
+		},
+		{
+			description: "Error - Missing parameters",
+			projectID:   "", region: "reg",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(
+			tt.description, func(t *testing.T) {
+				var currentPage int64
+				getFlavorsMock := func(_ v3alpha1api.ApiGetFlavorsRequestRequest) (*v3alpha1api.GetFlavorsResponse, error) {
+					currentPage++
+					return mockResp(currentPage)
+				}
+
+				client := v3alpha1api.DefaultAPIServiceMock{
+					GetFlavorsRequestExecuteMock: &getFlavorsMock,
+				}
+				actual, err := getFlavorsByFilter(context.Background(), client, tt.projectID, tt.region, tt.filter)
+
+				if (err != nil) != tt.wantErr {
+					t.Errorf("getFlavorsByFilter() error = %v, wantErr %v", err, tt.wantErr)
+					return
+				}
+
+				if !tt.wantErr && len(actual) != tt.wantCount {
+					t.Errorf("getFlavorsByFilter() got %d flavors, want %d", len(actual), tt.wantCount)
+				}
+			},
+		)
+	}
+}
+
+func TestGetAllFlavors(t *testing.T) {
+	var currentPage int64
+
+	getFlavorsMock := func(_ v3alpha1api.ApiGetFlavorsRequestRequest) (*v3alpha1api.GetFlavorsResponse, error) {
+		currentPage++
+		return mockResp(currentPage)
+	}
+
+	client := v3alpha1api.DefaultAPIServiceMock{
+		GetFlavorsRequestExecuteMock: &getFlavorsMock,
+	}
+
+	res, err := getAllFlavors(context.Background(), client, "pid", "reg")
+	if err != nil {
+		t.Errorf("getAllFlavors() unexpected error: %v", err)
+	}
+	if len(res) != 3 {
+		t.Errorf("getAllFlavors() expected 3 flavor, got %d", len(res))
+	}
+}

stackit/internal/services/sqlserverflexalpha/flavors/datasource.go

@@ -0,0 +1,156 @@
+package sqlserverflexalpha
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource"
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/hashicorp/terraform-plugin-log/tflog"
+	"github.com/stackitcloud/stackit-sdk-go/core/config"
+
+	"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"
+
+	sqlserverflexalphaPkg "github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3alpha1api"
+
+	sqlserverflexalphaGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/flavors/datasources_gen"
+)
+
+var _ datasource.DataSource = (*flavorsDataSource)(nil)
+
+const errorPrefix = "[sqlserverflexalpha - Flavors]"
+
+func NewFlavorsDataSource() datasource.DataSource {
+	return &flavorsDataSource{}
+}
+
+type dataSourceModel struct {
+	sqlserverflexalphaGen.FlavorsModel
+	TerraformId types.String `tfsdk:"id"`
+}
+
+type flavorsDataSource struct {
+	client       *sqlserverflexalphaPkg.APIClient
+	providerData core.ProviderData
+}
+
+func (d *flavorsDataSource) Metadata(
+	_ context.Context,
+	req datasource.MetadataRequest,
+	resp *datasource.MetadataResponse,
+) {
+	resp.TypeName = req.ProviderTypeName + "_sqlserverflexalpha_flavors"
+}
+
+func (d *flavorsDataSource) Schema(ctx context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	resp.Schema = sqlserverflexalphaGen.FlavorsDataSourceSchema(ctx)
+	resp.Schema.Attributes["id"] = schema.StringAttribute{
+		Computed:            true,
+		Description:         "The terraform internal identifier.",
+		MarkdownDescription: "The terraform internal identifier.",
+	}
+}
+
+// Configure adds the provider configured client to the data source.
+func (d *flavorsDataSource) Configure(
+	ctx context.Context,
+	req datasource.ConfigureRequest,
+	resp *datasource.ConfigureResponse,
+) {
+	var ok bool
+	d.providerData, ok = conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
+	if !ok {
+		return
+	}
+
+	apiClientConfigOptions := []config.ConfigurationOption{
+		config.WithCustomAuth(d.providerData.RoundTripper),
+		utils.UserAgentConfigOption(d.providerData.Version),
+	}
+	if d.providerData.SQLServerFlexCustomEndpoint != "" {
+		apiClientConfigOptions = append(
+			apiClientConfigOptions,
+			config.WithEndpoint(d.providerData.SQLServerFlexCustomEndpoint),
+		)
+	} else {
+		apiClientConfigOptions = append(
+			apiClientConfigOptions,
+			config.WithRegion(d.providerData.GetRegion()),
+		)
+	}
+	apiClient, err := sqlserverflexalphaPkg.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,
+			),
+		)
+		return
+	}
+	d.client = apiClient
+	tflog.Info(ctx, fmt.Sprintf("%s client configured", errorPrefix))
+}
+
+func (d *flavorsDataSource) 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)...)
+
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	ctx = core.InitProviderContext(ctx)
+
+	projectId := data.ProjectId.ValueString()
+	region := d.providerData.GetRegionWithOverride(data.Region)
+	// TODO: implement right identifier for flavors
+	flavorsId := data.Flavors
+
+	ctx = tflog.SetField(ctx, "project_id", projectId)
+	ctx = tflog.SetField(ctx, "region", region)
+
+	// TODO: implement needed fields
+	ctx = tflog.SetField(ctx, "flavors_id", flavorsId)
+
+	// TODO: refactor to correct implementation
+	_, err := d.client.DefaultAPI.GetFlavorsRequest(ctx, projectId, region).Execute()
+	if err != nil {
+		utils.LogError(
+			ctx,
+			&resp.Diagnostics,
+			err,
+			"Reading flavors",
+			fmt.Sprintf("flavors with ID %q does not exist in project %q.", flavorsId, projectId),
+			map[int]string{
+				http.StatusForbidden: fmt.Sprintf("Project with ID %q not found or forbidden access", projectId),
+			},
+		)
+		resp.State.RemoveResource(ctx)
+		return
+	}
+
+	ctx = core.LogResponse(ctx)
+
+	// TODO: refactor to correct implementation of internal tf id
+	data.TerraformId = utils.BuildInternalTerraformId(projectId, region)
+
+	// TODO: fill remaining fields
+	// data.Flavors = types.Sometype(apiResponse.GetFlavors())
+	// data.Page = types.Sometype(apiResponse.GetPage())
+	// data.Pagination = types.Sometype(apiResponse.GetPagination())
+	// data.ProjectId = types.Sometype(apiResponse.GetProjectId())
+	// data.Region = types.Sometype(apiResponse.GetRegion())
+	// data.Size = types.Sometype(apiResponse.GetSize())
+	// data.Sort = types.Sometype(apiResponse.GetSort())// Save data into Terraform state
+	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
+
+	tflog.Info(ctx, fmt.Sprintf("%s read successful", errorPrefix))
+}

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

@@ -1,232 +1,125 @@
-package sqlserverflex
+package sqlserverflexalpha
 
 import (
 	"context"
 	"fmt"
 	"net/http"
 
-	"github.com/hashicorp/terraform-plugin-framework/types"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/conversion"
-	sqlserverflexUtils "github.com/stackitcloud/terraform-provider-stackit/stackit/internal/services/sqlserverflexalpha/utils"
-
-	sqlserverflex "github.com/stackitcloud/terraform-provider-stackit/pkg/sqlserverflexalpha"
-
 	"github.com/hashicorp/terraform-plugin-framework/datasource"
-	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
-	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
+	"github.com/hashicorp/terraform-plugin-framework/types"
 	"github.com/hashicorp/terraform-plugin-log/tflog"
-	"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/stackitcloud/stackit-sdk-go/core/config"
 
-	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+	"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"
+
+	"github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3alpha1api"
+
+	sqlserverflexalphaGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/instance/datasources_gen"
 )
 
-// Ensure the implementation satisfies the expected interfaces.
-var (
-	_ datasource.DataSource = &instanceDataSource{}
-)
+var _ datasource.DataSource = (*instanceDataSource)(nil)
+
+const errorPrefix = "[sqlserverflexalpha - Instance]"
 
-// NewInstanceDataSource is a helper function to simplify the provider implementation.
 func NewInstanceDataSource() datasource.DataSource {
 	return &instanceDataSource{}
 }
 
-// instanceDataSource is the data source implementation.
+// dataSourceModel maps the data source schema data.
+type dataSourceModel struct {
+	sqlserverflexalphaGen.InstanceModel
+	TerraformID types.String `tfsdk:"id"`
+}
+
 type instanceDataSource struct {
-	client       *sqlserverflex.APIClient
+	client       *v3alpha1api.APIClient
 	providerData core.ProviderData
 }
 
-// Metadata returns the data source type name.
-func (r *instanceDataSource) Metadata(_ context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {
+func (d *instanceDataSource) Metadata(
+	_ context.Context,
+	req datasource.MetadataRequest,
+	resp *datasource.MetadataResponse,
+) {
 	resp.TypeName = req.ProviderTypeName + "_sqlserverflexalpha_instance"
 }
 
+func (d *instanceDataSource) Schema(ctx context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	resp.Schema = sqlserverflexalphaGen.InstanceDataSourceSchema(ctx)
+}
+
 // Configure adds the provider configured client to the data source.
-func (r *instanceDataSource) Configure(ctx context.Context, req datasource.ConfigureRequest, resp *datasource.ConfigureResponse) {
+func (d *instanceDataSource) Configure(
+	ctx context.Context,
+	req datasource.ConfigureRequest,
+	resp *datasource.ConfigureResponse,
+) {
 	var ok bool
-	r.providerData, ok = conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
+	d.providerData, ok = conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
 	if !ok {
 		return
 	}
 
-	apiClient := sqlserverflexUtils.ConfigureClient(ctx, &r.providerData, &resp.Diagnostics)
-	if resp.Diagnostics.HasError() {
+	apiClientConfigOptions := []config.ConfigurationOption{
+		config.WithCustomAuth(d.providerData.RoundTripper),
+		utils.UserAgentConfigOption(d.providerData.Version),
+	}
+	if d.providerData.SQLServerFlexCustomEndpoint != "" {
+		apiClientConfigOptions = append(
+			apiClientConfigOptions,
+			config.WithEndpoint(d.providerData.SQLServerFlexCustomEndpoint),
+		)
+	} else {
+		apiClientConfigOptions = append(
+			apiClientConfigOptions,
+			config.WithRegion(d.providerData.GetRegion()),
+		)
+	}
+	apiClient, err := v3alpha1api.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,
+			),
+		)
 		return
 	}
-	r.client = apiClient
-	tflog.Info(ctx, "SQLServer Flex instance client configured")
+	d.client = apiClient
+	tflog.Info(ctx, fmt.Sprintf("%s client configured", errorPrefix))
 }
 
-// Schema defines the schema for the data source.
-func (r *instanceDataSource) Schema(_ context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
-	descriptions := map[string]string{
-		"main":            "SQLServer Flex instance data source schema. Must have a `region` specified in the provider configuration.",
-		"id":              "Terraform's internal data source. ID. It is structured as \"`project_id`,`region`,`instance_id`\".",
-		"instance_id":     "ID of the SQLServer Flex instance.",
-		"project_id":      "STACKIT project ID to which the instance is associated.",
-		"name":            "Instance name.",
-		"acl":             "The Access Control List (ACL) for the SQLServer Flex instance.",
-		"backup_schedule": `The backup schedule. Should follow the cron scheduling system format (e.g. "0 0 * * *").`,
-		"options":         "Custom parameters for the SQLServer Flex instance.",
-		"region":          "The resource region. If not defined, the provider region is used.",
-		// TODO
-	}
+func (d *instanceDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) {
+	var data dataSourceModel
 
-	resp.Schema = schema.Schema{
-		Description: descriptions["main"],
-		Attributes: map[string]schema.Attribute{
-			"id": schema.StringAttribute{
-				Description: descriptions["id"],
-				Computed:    true,
-			},
-			"instance_id": schema.StringAttribute{
-				Description: descriptions["instance_id"],
-				Required:    true,
-				Validators: []validator.String{
-					validate.UUID(),
-					validate.NoSeparator(),
-				},
-			},
-			"project_id": schema.StringAttribute{
-				Description: descriptions["project_id"],
-				Required:    true,
-				Validators: []validator.String{
-					validate.UUID(),
-					validate.NoSeparator(),
-				},
-			},
-			"name": schema.StringAttribute{
-				Description: descriptions["name"],
-				Computed:    true,
-			},
-			"backup_schedule": schema.StringAttribute{
-				Description: descriptions["backup_schedule"],
-				Computed:    true,
-			},
-			"flavor": schema.SingleNestedAttribute{
-				Computed: true,
-				Attributes: map[string]schema.Attribute{
-					"id": schema.StringAttribute{
-						Computed: true,
-					},
-					"description": schema.StringAttribute{
-						Computed: true,
-					},
-					"cpu": schema.Int64Attribute{
-						Computed: true,
-					},
-					"ram": schema.Int64Attribute{
-						Computed: true,
-					},
-				},
-			},
-			"replicas": schema.Int64Attribute{
-				Computed: true,
-			},
-			"storage": schema.SingleNestedAttribute{
-				Computed: true,
-				Attributes: map[string]schema.Attribute{
-					"class": schema.StringAttribute{
-						Computed: true,
-					},
-					"size": schema.Int64Attribute{
-						Computed: true,
-					},
-				},
-			},
-			"version": schema.StringAttribute{
-				Computed: true,
-			},
-			"status": schema.StringAttribute{
-				Computed: true,
-			},
-			"edition": schema.StringAttribute{
-				Computed: true,
-			},
-			"retention_days": schema.Int64Attribute{
-				Computed: true,
-			},
-			"region": schema.StringAttribute{
-				// the region cannot be found, so it has to be passed
-				Optional:    true,
-				Description: descriptions["region"],
-			},
-			"encryption": schema.SingleNestedAttribute{
-				Computed: true,
-				Attributes: map[string]schema.Attribute{
-					"key_id": schema.StringAttribute{
-						Description: descriptions["key_id"],
-						Computed:    true,
-					},
-					"key_version": schema.StringAttribute{
-						Description: descriptions["key_version"],
-						Computed:    true,
-					},
-					"keyring_id": schema.StringAttribute{
-						Description: descriptions["keyring_id"],
-						Computed:    true,
-					},
-					"service_account": schema.StringAttribute{
-						Description: descriptions["service_account"],
-						Computed:    true,
-					},
-				},
-				Description: descriptions["encryption"],
-			},
-			"network": schema.SingleNestedAttribute{
-				Computed: true,
-				Attributes: map[string]schema.Attribute{
-					"access_scope": schema.StringAttribute{
-						Description: descriptions["access_scope"],
-						Computed:    true,
-					},
-					"instance_address": schema.StringAttribute{
-						Description: descriptions["instance_address"],
-						Computed:    true,
-					},
-					"router_address": schema.StringAttribute{
-						Description: descriptions["router_address"],
-						Computed:    true,
-					},
-					"acl": schema.ListAttribute{
-						Description: descriptions["acl"],
-						ElementType: types.StringType,
-						Computed:    true,
-					},
-				},
-				Description: descriptions["network"],
-			},
-		},
-	}
-}
+	// Read Terraform configuration data into the model
+	resp.Diagnostics.Append(req.Config.Get(ctx, &data)...)
 
-// Read refreshes the Terraform state with the latest data.
-func (r *instanceDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) { // nolint:gocritic // function signature required by Terraform
-	var model Model
-	diags := req.Config.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 := r.providerData.GetRegionWithOverride(model.Region)
+	projectId := data.ProjectId.ValueString()
+	region := d.providerData.GetRegionWithOverride(data.Region)
+	instanceId := data.InstanceId.ValueString()
+
 	ctx = tflog.SetField(ctx, "project_id", projectId)
-	ctx = tflog.SetField(ctx, "instance_id", instanceId)
 	ctx = tflog.SetField(ctx, "region", region)
-	instanceResp, err := r.client.GetInstanceRequest(ctx, projectId, region, instanceId).Execute()
+	ctx = tflog.SetField(ctx, "instance_id", instanceId)
+
+	instanceResp, err := d.client.DefaultAPI.GetInstanceRequest(ctx, projectId, region, instanceId).Execute()
 	if err != nil {
 		utils.LogError(
 			ctx,
 			&resp.Diagnostics,
 			err,
 			"Reading instance",
-			fmt.Sprintf("Instance with ID %q does not exist in project %q.", instanceId, projectId),
+			fmt.Sprintf("instance with ID %q does not exist in project %q.", instanceId, projectId),
 			map[int]string{
 				http.StatusForbidden: fmt.Sprintf("Project with ID %q not found or forbidden access", projectId),
 			},
@@ -237,59 +130,17 @@ func (r *instanceDataSource) Read(ctx context.Context, req datasource.ReadReques
 
 	ctx = core.LogResponse(ctx)
 
-	var flavor = &flavorModel{}
-	if model.Flavor.IsNull() || model.Flavor.IsUnknown() {
-		flavor.Id = types.StringValue(*instanceResp.FlavorId)
-		if flavor.Id.IsNull() || flavor.Id.IsUnknown() || flavor.Id.String() == "" {
-			panic("WTF FlavorId can not be null or empty string")
-		}
-		err = getFlavorModelById(ctx, r.client, &model, flavor)
-		if err != nil {
-			resp.Diagnostics.AddError(err.Error(), err.Error())
-			return
-		}
-		if flavor.CPU.IsNull() || flavor.CPU.IsUnknown() || flavor.CPU.String() == "" {
-			panic("WTF FlavorId can not be null or empty string")
-		}
-	}
-
-	var storage = &storageModel{}
-	if !(model.Storage.IsNull() || model.Storage.IsUnknown()) {
-		diags = model.Storage.As(ctx, storage, basetypes.ObjectAsOptions{})
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-
-	var encryption = &encryptionModel{}
-	if !(model.Encryption.IsNull() || model.Encryption.IsUnknown()) {
-		diags = model.Encryption.As(ctx, encryption, basetypes.ObjectAsOptions{})
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-
-	var network = &networkModel{}
-	if !(model.Network.IsNull() || model.Network.IsUnknown()) {
-		diags = model.Network.As(ctx, network, basetypes.ObjectAsOptions{})
-		resp.Diagnostics.Append(diags...)
-		if resp.Diagnostics.HasError() {
-			return
-		}
-	}
-
-	err = mapFields(ctx, instanceResp, &model, flavor, storage, encryption, network, region)
+	err = mapDataResponseToModel(ctx, instanceResp, &data, resp.Diagnostics)
 	if err != nil {
-		core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading instance", fmt.Sprintf("Processing API payload: %v", err))
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			fmt.Sprintf("%s Read", errorPrefix),
+			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 instance read")
+
+	// Save data into Terraform state
+	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
 }

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
-}

stackit/internal/services/sqlserverflexalpha/instance/planModifiers.yaml

@@ -0,0 +1,124 @@
+fields:
+  - name: 'id'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'instance_id'
+    validators:
+      - validate.NoSeparator
+      - validate.UUID
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'project_id'
+    validators:
+      - validate.NoSeparator
+      - validate.UUID
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'name'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'backup_schedule'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'encryption.kek_key_id'
+    validators:
+      - validate.NoSeparator
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'encryption.kek_key_version'
+    validators:
+      - validate.NoSeparator
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'encryption.kek_key_ring_id'
+    validators:
+      - validate.NoSeparator
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'encryption.service_account'
+    validators:
+      - validate.NoSeparator
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'network.access_scope'
+    validators:
+      - validate.NoSeparator
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'network.acl'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'network.instance_address'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'network.router_address'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'status'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'region'
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'retention_days'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'edition'
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'version'
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'replicas'
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'storage'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'storage.class'
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'storage.size'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'flavor_id'
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'is_deletable'
+    modifiers:
+      - 'UseStateForUnknown'

stackit/internal/services/sqlserverflexalpha/instance/resource_msh_test.go.bak

@@ -1,282 +0,0 @@
-// Copyright (c) STACKIT
-
-package sqlserverflex
-
-import (
-	"context"
-	"reflect"
-	"testing"
-
-	"github.com/hashicorp/terraform-plugin-framework/resource"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
-
-	sqlserverflex "github.com/stackitcloud/terraform-provider-stackit/pkg/sqlserverflexalpha"
-)
-
-func TestNewInstanceResource(t *testing.T) {
-	tests := []struct {
-		name string
-		want resource.Resource
-	}{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := NewInstanceResource(); !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("NewInstanceResource() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func Test_instanceResource_Configure(t *testing.T) {
-	type fields struct {
-		client       *sqlserverflex.APIClient
-		providerData core.ProviderData
-	}
-	type args struct {
-		ctx  context.Context
-		req  resource.ConfigureRequest
-		resp *resource.ConfigureResponse
-	}
-	tests := []struct {
-		name   string
-		fields fields
-		args   args
-	}{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			r := &instanceResource{
-				client:       tt.fields.client,
-				providerData: tt.fields.providerData,
-			}
-			r.Configure(tt.args.ctx, tt.args.req, tt.args.resp)
-		})
-	}
-}
-
-func Test_instanceResource_Create(t *testing.T) {
-	type fields struct {
-		client       *sqlserverflex.APIClient
-		providerData core.ProviderData
-	}
-	type args struct {
-		ctx  context.Context
-		req  resource.CreateRequest
-		resp *resource.CreateResponse
-	}
-	tests := []struct {
-		name   string
-		fields fields
-		args   args
-	}{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			r := &instanceResource{
-				client:       tt.fields.client,
-				providerData: tt.fields.providerData,
-			}
-			r.Create(tt.args.ctx, tt.args.req, tt.args.resp)
-		})
-	}
-}
-
-func Test_instanceResource_Delete(t *testing.T) {
-	type fields struct {
-		client       *sqlserverflex.APIClient
-		providerData core.ProviderData
-	}
-	type args struct {
-		ctx  context.Context
-		req  resource.DeleteRequest
-		resp *resource.DeleteResponse
-	}
-	tests := []struct {
-		name   string
-		fields fields
-		args   args
-	}{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			r := &instanceResource{
-				client:       tt.fields.client,
-				providerData: tt.fields.providerData,
-			}
-			r.Delete(tt.args.ctx, tt.args.req, tt.args.resp)
-		})
-	}
-}
-
-func Test_instanceResource_ImportState(t *testing.T) {
-	type fields struct {
-		client       *sqlserverflex.APIClient
-		providerData core.ProviderData
-	}
-	type args struct {
-		ctx  context.Context
-		req  resource.ImportStateRequest
-		resp *resource.ImportStateResponse
-	}
-	tests := []struct {
-		name   string
-		fields fields
-		args   args
-	}{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			r := &instanceResource{
-				client:       tt.fields.client,
-				providerData: tt.fields.providerData,
-			}
-			r.ImportState(tt.args.ctx, tt.args.req, tt.args.resp)
-		})
-	}
-}
-
-func Test_instanceResource_Metadata(t *testing.T) {
-	type fields struct {
-		client       *sqlserverflex.APIClient
-		providerData core.ProviderData
-	}
-	type args struct {
-		in0  context.Context
-		req  resource.MetadataRequest
-		resp *resource.MetadataResponse
-	}
-	tests := []struct {
-		name   string
-		fields fields
-		args   args
-	}{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			r := &instanceResource{
-				client:       tt.fields.client,
-				providerData: tt.fields.providerData,
-			}
-			r.Metadata(tt.args.in0, tt.args.req, tt.args.resp)
-		})
-	}
-}
-
-func Test_instanceResource_ModifyPlan(t *testing.T) {
-	type fields struct {
-		client       *sqlserverflex.APIClient
-		providerData core.ProviderData
-	}
-	type args struct {
-		ctx  context.Context
-		req  resource.ModifyPlanRequest
-		resp *resource.ModifyPlanResponse
-	}
-	tests := []struct {
-		name   string
-		fields fields
-		args   args
-	}{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			r := &instanceResource{
-				client:       tt.fields.client,
-				providerData: tt.fields.providerData,
-			}
-			r.ModifyPlan(tt.args.ctx, tt.args.req, tt.args.resp)
-		})
-	}
-}
-
-func Test_instanceResource_Read(t *testing.T) {
-	type fields struct {
-		client       *sqlserverflex.APIClient
-		providerData core.ProviderData
-	}
-	type args struct {
-		ctx  context.Context
-		req  resource.ReadRequest
-		resp *resource.ReadResponse
-	}
-	tests := []struct {
-		name   string
-		fields fields
-		args   args
-	}{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			r := &instanceResource{
-				client:       tt.fields.client,
-				providerData: tt.fields.providerData,
-			}
-			r.Read(tt.args.ctx, tt.args.req, tt.args.resp)
-		})
-	}
-}
-
-func Test_instanceResource_Schema(t *testing.T) {
-	type fields struct {
-		client       *sqlserverflex.APIClient
-		providerData core.ProviderData
-	}
-	type args struct {
-		in0  context.Context
-		in1  resource.SchemaRequest
-		resp *resource.SchemaResponse
-	}
-	tests := []struct {
-		name   string
-		fields fields
-		args   args
-	}{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			r := &instanceResource{
-				client:       tt.fields.client,
-				providerData: tt.fields.providerData,
-			}
-			r.Schema(tt.args.in0, tt.args.in1, tt.args.resp)
-		})
-	}
-}
-
-func Test_instanceResource_Update(t *testing.T) {
-	type fields struct {
-		client       *sqlserverflex.APIClient
-		providerData core.ProviderData
-	}
-	type args struct {
-		ctx  context.Context
-		req  resource.UpdateRequest
-		resp *resource.UpdateResponse
-	}
-	tests := []struct {
-		name   string
-		fields fields
-		args   args
-	}{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			r := &instanceResource{
-				client:       tt.fields.client,
-				providerData: tt.fields.providerData,
-			}
-			r.Update(tt.args.ctx, tt.args.req, tt.args.resp)
-		})
-	}
-}

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

@@ -1,862 +0,0 @@
-package sqlserverflex
-
-import (
-	"context"
-	"fmt"
-	"testing"
-
-	"github.com/google/go-cmp/cmp"
-	"github.com/hashicorp/terraform-plugin-framework/attr"
-	"github.com/hashicorp/terraform-plugin-framework/types"
-	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
-	"github.com/stackitcloud/stackit-sdk-go/core/utils"
-	sqlserverflex "github.com/stackitcloud/terraform-provider-stackit/pkg/sqlserverflexalpha"
-)
-
-type sqlserverflexClientMocked struct {
-	returnError     bool
-	listFlavorsResp *sqlserverflex.GetFlavorsResponse
-}
-
-func (c *sqlserverflexClientMocked) GetFlavorsExecute(_ context.Context, _, _ string) (*sqlserverflex.GetFlavorsResponse, error) {
-	if c.returnError {
-		return nil, fmt.Errorf("get flavors failed")
-	}
-
-	return c.listFlavorsResp, nil
-}
-
-func TestMapFields(t *testing.T) {
-	const testRegion = "region"
-	tests := []struct {
-		description string
-		state       Model
-		input       *sqlserverflex.GetInstanceResponse
-		flavor      *flavorModel
-		storage     *storageModel
-		encryption  *encryptionModel
-		network     *networkModel
-		region      string
-		expected    Model
-		isValid     bool
-	}{
-		{
-			"default_values",
-			Model{
-				InstanceId:    types.StringValue("iid"),
-				ProjectId:     types.StringValue("pid"),
-				Replicas:      types.Int64Value(1),
-				RetentionDays: types.Int64Value(1),
-				Version:       types.StringValue("v1"),
-				Edition:       types.StringValue("edition 1"),
-				Status:        types.StringValue("status"),
-				IsDeletable:   types.BoolValue(true),
-				Flavor: types.ObjectValueMust(flavorTypes, map[string]attr.Value{
-					"id":          types.StringValue("flavor_id"),
-					"description": types.StringNull(),
-					"cpu":         types.Int64Null(),
-					"ram":         types.Int64Null(),
-					"node_type":   types.StringNull(),
-				}),
-			},
-			&sqlserverflex.GetInstanceResponse{
-				FlavorId:      utils.Ptr("flavor_id"),
-				Replicas:      sqlserverflex.GetInstanceResponseGetReplicasAttributeType(utils.Ptr(int32(1))),
-				RetentionDays: utils.Ptr(int64(1)),
-				Version:       sqlserverflex.GetInstanceResponseGetVersionAttributeType(utils.Ptr("v1")),
-				Edition:       sqlserverflex.GetInstanceResponseGetEditionAttributeType(utils.Ptr("edition 1")),
-				Status:        sqlserverflex.GetInstanceResponseGetStatusAttributeType(utils.Ptr("status")),
-				IsDeletable:   utils.Ptr(true),
-			},
-			&flavorModel{
-				Id: types.StringValue("flavor_id"),
-			},
-			&storageModel{},
-			&encryptionModel{},
-			&networkModel{
-				ACL: types.ListNull(basetypes.StringType{}),
-			},
-			testRegion,
-			Model{
-				Id:             types.StringValue("pid,region,iid"),
-				InstanceId:     types.StringValue("iid"),
-				ProjectId:      types.StringValue("pid"),
-				Name:           types.StringNull(),
-				BackupSchedule: types.StringNull(),
-				Flavor: types.ObjectValueMust(flavorTypes, map[string]attr.Value{
-					"id":          types.StringValue("flavor_id"),
-					"description": types.StringNull(),
-					"cpu":         types.Int64Null(),
-					"ram":         types.Int64Null(),
-					"node_type":   types.StringNull(),
-				}),
-				Replicas: types.Int64Value(1),
-				Storage: types.ObjectValueMust(storageTypes, map[string]attr.Value{
-					"class": types.StringNull(),
-					"size":  types.Int64Null(),
-				}),
-				Encryption: types.ObjectValueMust(encryptionTypes, map[string]attr.Value{
-					"keyring_id":      types.StringNull(),
-					"key_id":          types.StringNull(),
-					"key_version":     types.StringNull(),
-					"service_account": types.StringNull(),
-				}),
-				Network: types.ObjectValueMust(networkTypes, map[string]attr.Value{
-					"acl":              types.ListNull(types.StringType),
-					"access_scope":     types.StringNull(),
-					"instance_address": types.StringNull(),
-					"router_address":   types.StringNull(),
-				}),
-				IsDeletable:   types.BoolValue(true),
-				Edition:       types.StringValue("edition 1"),
-				Status:        types.StringValue("status"),
-				RetentionDays: types.Int64Value(1),
-				Version:       types.StringValue("v1"),
-				Region:        types.StringValue(testRegion),
-			},
-			true,
-		},
-		{
-			"simple_values",
-			Model{
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-			},
-			&sqlserverflex.GetInstanceResponse{
-				Acl: &[]string{
-					"ip1",
-					"ip2",
-					"",
-				},
-				BackupSchedule: utils.Ptr("schedule"),
-				FlavorId:       utils.Ptr("flavor_id"),
-				Id:             utils.Ptr("iid"),
-				Name:           utils.Ptr("name"),
-				Replicas:       sqlserverflex.GetInstanceResponseGetReplicasAttributeType(utils.Ptr(int32(56))),
-				Status:         sqlserverflex.GetInstanceResponseGetStatusAttributeType(utils.Ptr("status")),
-				Storage: &sqlserverflex.Storage{
-					Class: utils.Ptr("class"),
-					Size:  utils.Ptr(int64(78)),
-				},
-				Edition:       sqlserverflex.GetInstanceResponseGetEditionAttributeType(utils.Ptr("edition")),
-				RetentionDays: utils.Ptr(int64(1)),
-				Version:       sqlserverflex.GetInstanceResponseGetVersionAttributeType(utils.Ptr("version")),
-				IsDeletable:   utils.Ptr(true),
-				Encryption:    nil,
-			},
-			&flavorModel{
-				Id:          basetypes.NewStringValue("flavor_id"),
-				Description: basetypes.NewStringValue("description"),
-				CPU:         basetypes.NewInt64Value(12),
-				RAM:         basetypes.NewInt64Value(34),
-				NodeType:    basetypes.NewStringValue("node_type"),
-			},
-			&storageModel{},
-			&encryptionModel{},
-			&networkModel{
-				ACL: types.ListValueMust(basetypes.StringType{}, []attr.Value{
-					types.StringValue("ip1"),
-					types.StringValue("ip2"),
-					types.StringValue(""),
-				}),
-			},
-			testRegion,
-			Model{
-				Id:             types.StringValue("pid,region,iid"),
-				InstanceId:     types.StringValue("iid"),
-				ProjectId:      types.StringValue("pid"),
-				Name:           types.StringValue("name"),
-				BackupSchedule: types.StringValue("schedule"),
-				Flavor: types.ObjectValueMust(flavorTypes, map[string]attr.Value{
-					"id":          types.StringValue("flavor_id"),
-					"description": types.StringValue("description"),
-					"cpu":         types.Int64Value(12),
-					"ram":         types.Int64Value(34),
-					"node_type":   types.StringValue("node_type"),
-				}),
-				Replicas: types.Int64Value(56),
-				Storage: types.ObjectValueMust(storageTypes, map[string]attr.Value{
-					"class": types.StringValue("class"),
-					"size":  types.Int64Value(78),
-				}),
-				Network: types.ObjectValueMust(networkTypes, map[string]attr.Value{
-					"acl": types.ListValueMust(types.StringType, []attr.Value{
-						types.StringValue("ip1"),
-						types.StringValue("ip2"),
-						types.StringValue(""),
-					}),
-					"access_scope":     types.StringNull(),
-					"instance_address": types.StringNull(),
-					"router_address":   types.StringNull(),
-				}),
-				Edition:       types.StringValue("edition"),
-				RetentionDays: types.Int64Value(1),
-				Version:       types.StringValue("version"),
-				Region:        types.StringValue(testRegion),
-				IsDeletable:   types.BoolValue(true),
-				Encryption: types.ObjectValueMust(encryptionTypes, map[string]attr.Value{
-					"keyring_id":      types.StringNull(),
-					"key_id":          types.StringNull(),
-					"key_version":     types.StringNull(),
-					"service_account": types.StringNull(),
-				}),
-				Status: types.StringValue("status"),
-			},
-			true,
-		},
-		//{
-		//	"simple_values_no_flavor_and_storage",
-		//	Model{
-		//		InstanceId: types.StringValue("iid"),
-		//		ProjectId:  types.StringValue("pid"),
-		//	},
-		//	&sqlserverflex.GetInstanceResponse{
-		//		Acl: &[]string{
-		//			"ip1",
-		//			"ip2",
-		//			"",
-		//		},
-		//		BackupSchedule: utils.Ptr("schedule"),
-		//		FlavorId:       nil,
-		//		Id:             utils.Ptr("iid"),
-		//		Name:           utils.Ptr("name"),
-		//		Replicas:       sqlserverflex.GetInstanceResponseGetReplicasAttributeType(utils.Ptr(int32(56))),
-		//		Status:         sqlserverflex.GetInstanceResponseGetStatusAttributeType(utils.Ptr("status")),
-		//		Storage:        nil,
-		//		Edition:        sqlserverflex.GetInstanceResponseGetEditionAttributeType(utils.Ptr("edition")),
-		//		RetentionDays:  utils.Ptr(int64(1)),
-		//		Version:        sqlserverflex.GetInstanceResponseGetVersionAttributeType(utils.Ptr("version")),
-		//	},
-		//	&flavorModel{
-		//		CPU: types.Int64Value(12),
-		//		RAM: types.Int64Value(34),
-		//	},
-		//	&storageModel{
-		//		Class: types.StringValue("class"),
-		//		Size:  types.Int64Value(78),
-		//	},
-		//	&optionsModel{
-		//		Edition:       types.StringValue("edition"),
-		//		RetentionDays: types.Int64Value(1),
-		//	},
-		//	testRegion,
-		//	Model{
-		//		Id:         types.StringValue("pid,region,iid"),
-		//		InstanceId: types.StringValue("iid"),
-		//		ProjectId:  types.StringValue("pid"),
-		//		Name:       types.StringValue("name"),
-		//		ACL: types.ListValueMust(types.StringType, []attr.Value{
-		//			types.StringValue("ip1"),
-		//			types.StringValue("ip2"),
-		//			types.StringValue(""),
-		//		}),
-		//		BackupSchedule: types.StringValue("schedule"),
-		//		Flavor: types.ObjectValueMust(flavorTypes, map[string]attr.Value{
-		//			"id":          types.StringNull(),
-		//			"description": types.StringNull(),
-		//			"cpu":         types.Int64Value(12),
-		//			"ram":         types.Int64Value(34),
-		//		}),
-		//		Replicas: types.Int64Value(56),
-		//		Storage: types.ObjectValueMust(storageTypes, map[string]attr.Value{
-		//			"class": types.StringValue("class"),
-		//			"size":  types.Int64Value(78),
-		//		}),
-		//		Options: types.ObjectValueMust(optionsTypes, map[string]attr.Value{
-		//			"edition":        types.StringValue("edition"),
-		//			"retention_days": types.Int64Value(1),
-		//		}),
-		//		Version: types.StringValue("version"),
-		//		Region:  types.StringValue(testRegion),
-		//	},
-		//	true,
-		//},
-		//{
-		//	"acls_unordered",
-		//	Model{
-		//		InstanceId: types.StringValue("iid"),
-		//		ProjectId:  types.StringValue("pid"),
-		//		ACL: types.ListValueMust(types.StringType, []attr.Value{
-		//			types.StringValue("ip2"),
-		//			types.StringValue(""),
-		//			types.StringValue("ip1"),
-		//		}),
-		//	},
-		//	&sqlserverflex.GetInstanceResponse{
-		//		Acl: &[]string{
-		//			"",
-		//			"ip1",
-		//			"ip2",
-		//		},
-		//		BackupSchedule: utils.Ptr("schedule"),
-		//		FlavorId:       nil,
-		//		Id:             utils.Ptr("iid"),
-		//		Name:           utils.Ptr("name"),
-		//		Replicas:       sqlserverflex.GetInstanceResponseGetReplicasAttributeType(utils.Ptr(int32(56))),
-		//		Status:         sqlserverflex.GetInstanceResponseGetStatusAttributeType(utils.Ptr("status")),
-		//		Storage:        nil,
-		//		//Options: &map[string]string{
-		//		//	"edition":       "edition",
-		//		//	"retentionDays": "1",
-		//		//},
-		//		Version: sqlserverflex.GetInstanceResponseGetVersionAttributeType(utils.Ptr("version")),
-		//	},
-		//	&flavorModel{
-		//		CPU: types.Int64Value(12),
-		//		RAM: types.Int64Value(34),
-		//	},
-		//	&storageModel{
-		//		Class: types.StringValue("class"),
-		//		Size:  types.Int64Value(78),
-		//	},
-		//	&optionsModel{},
-		//	testRegion,
-		//	Model{
-		//		Id:         types.StringValue("pid,region,iid"),
-		//		InstanceId: types.StringValue("iid"),
-		//		ProjectId:  types.StringValue("pid"),
-		//		Name:       types.StringValue("name"),
-		//		ACL: types.ListValueMust(types.StringType, []attr.Value{
-		//			types.StringValue("ip2"),
-		//			types.StringValue(""),
-		//			types.StringValue("ip1"),
-		//		}),
-		//		BackupSchedule: types.StringValue("schedule"),
-		//		Flavor: types.ObjectValueMust(flavorTypes, map[string]attr.Value{
-		//			"id":          types.StringNull(),
-		//			"description": types.StringNull(),
-		//			"cpu":         types.Int64Value(12),
-		//			"ram":         types.Int64Value(34),
-		//		}),
-		//		Replicas: types.Int64Value(56),
-		//		Storage: types.ObjectValueMust(storageTypes, map[string]attr.Value{
-		//			"class": types.StringValue("class"),
-		//			"size":  types.Int64Value(78),
-		//		}),
-		//		Options: types.ObjectValueMust(optionsTypes, map[string]attr.Value{
-		//			"edition":        types.StringValue("edition"),
-		//			"retention_days": types.Int64Value(1),
-		//		}),
-		//		Version: types.StringValue("version"),
-		//		Region:  types.StringValue(testRegion),
-		//	},
-		//	true,
-		//},
-		//{
-		//	"nil_response",
-		//	Model{
-		//		InstanceId: types.StringValue("iid"),
-		//		ProjectId:  types.StringValue("pid"),
-		//	},
-		//	nil,
-		//	&flavorModel{},
-		//	&storageModel{},
-		//	&optionsModel{},
-		//	testRegion,
-		//	Model{},
-		//	false,
-		//},
-		//{
-		//	"no_resource_id",
-		//	Model{
-		//		InstanceId: types.StringValue("iid"),
-		//		ProjectId:  types.StringValue("pid"),
-		//	},
-		//	&sqlserverflex.GetInstanceResponse{},
-		//	&flavorModel{},
-		//	&storageModel{},
-		//	&optionsModel{},
-		//	testRegion,
-		//	Model{},
-		//	false,
-		//},
-	}
-	for _, tt := range tests {
-		t.Run(tt.description, func(t *testing.T) {
-			err := mapFields(context.Background(), tt.input, &tt.state, tt.flavor, tt.storage, tt.encryption, tt.network, 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(tt.state, tt.expected)
-				if diff != "" {
-					t.Fatalf("Data does not match: %s", diff)
-				}
-			}
-		})
-	}
-}
-
-//func TestToCreatePayload(t *testing.T) {
-//	tests := []struct {
-//		description  string
-//		input        *Model
-//		inputAcl     []string
-//		inputFlavor  *flavorModel
-//		inputStorage *storageModel
-//		inputOptions *optionsModel
-//		expected     *sqlserverflex.CreateInstanceRequestPayload
-//		isValid      bool
-//	}{
-//		{
-//			"default_values",
-//			&Model{},
-//			[]string{},
-//			&flavorModel{},
-//			&storageModel{},
-//			&optionsModel{},
-//			&sqlserverflex.CreateInstanceRequestPayload{
-//				Acl:     &sqlserverflex.CreateInstanceRequestPayloadGetAclArgType{},
-//				Storage: &sqlserverflex.CreateInstanceRequestPayloadGetStorageArgType{},
-//			},
-//			true,
-//		},
-//		{
-//			"simple_values",
-//			&Model{
-//				BackupSchedule: types.StringValue("schedule"),
-//				Name:           types.StringValue("name"),
-//				Replicas:       types.Int64Value(12),
-//				Version:        types.StringValue("version"),
-//			},
-//			[]string{
-//				"ip_1",
-//				"ip_2",
-//			},
-//			&flavorModel{
-//				Id: types.StringValue("flavor_id"),
-//			},
-//			&storageModel{
-//				Class: types.StringValue("class"),
-//				Size:  types.Int64Value(34),
-//			},
-//			&optionsModel{
-//				Edition:       types.StringValue("edition"),
-//				RetentionDays: types.Int64Value(1),
-//			},
-//			&sqlserverflex.CreateInstancePayload{
-//				Acl: &sqlserverflex.CreateInstancePayloadAcl{
-//					Items: &[]string{
-//						"ip_1",
-//						"ip_2",
-//					},
-//				},
-//				BackupSchedule: utils.Ptr("schedule"),
-//				FlavorId:       utils.Ptr("flavor_id"),
-//				Name:           utils.Ptr("name"),
-//				Storage: &sqlserverflex.CreateInstancePayloadStorage{
-//					Class: utils.Ptr("class"),
-//					Size:  utils.Ptr(int64(34)),
-//				},
-//				Options: &sqlserverflex.CreateInstancePayloadOptions{
-//					Edition:       utils.Ptr("edition"),
-//					RetentionDays: utils.Ptr("1"),
-//				},
-//				Version: utils.Ptr("version"),
-//			},
-//			true,
-//		},
-//		{
-//			"null_fields_and_int_conversions",
-//			&Model{
-//				BackupSchedule: types.StringNull(),
-//				Name:           types.StringNull(),
-//				Replicas:       types.Int64Value(2123456789),
-//				Version:        types.StringNull(),
-//			},
-//			[]string{
-//				"",
-//			},
-//			&flavorModel{
-//				Id: types.StringNull(),
-//			},
-//			&storageModel{
-//				Class: types.StringNull(),
-//				Size:  types.Int64Null(),
-//			},
-//			&optionsModel{
-//				Edition:       types.StringNull(),
-//				RetentionDays: types.Int64Null(),
-//			},
-//			&sqlserverflex.CreateInstancePayload{
-//				Acl: &sqlserverflex.CreateInstancePayloadAcl{
-//					Items: &[]string{
-//						"",
-//					},
-//				},
-//				BackupSchedule: nil,
-//				FlavorId:       nil,
-//				Name:           nil,
-//				Storage: &sqlserverflex.CreateInstancePayloadStorage{
-//					Class: nil,
-//					Size:  nil,
-//				},
-//				Options: &sqlserverflex.CreateInstancePayloadOptions{},
-//				Version: nil,
-//			},
-//			true,
-//		},
-//		{
-//			"nil_model",
-//			nil,
-//			[]string{},
-//			&flavorModel{},
-//			&storageModel{},
-//			&optionsModel{},
-//			nil,
-//			false,
-//		},
-//		{
-//			"nil_acl",
-//			&Model{},
-//			nil,
-//			&flavorModel{},
-//			&storageModel{},
-//			&optionsModel{},
-//			&sqlserverflex.CreateInstancePayload{
-//				Acl:     &sqlserverflex.CreateInstancePayloadAcl{},
-//				Storage: &sqlserverflex.CreateInstancePayloadStorage{},
-//				Options: &sqlserverflex.CreateInstancePayloadOptions{},
-//			},
-//			true,
-//		},
-//		{
-//			"nil_flavor",
-//			&Model{},
-//			[]string{},
-//			nil,
-//			&storageModel{},
-//			&optionsModel{},
-//			nil,
-//			false,
-//		},
-//		{
-//			"nil_storage",
-//			&Model{},
-//			[]string{},
-//			&flavorModel{},
-//			nil,
-//			&optionsModel{},
-//			&sqlserverflex.CreateInstancePayload{
-//				Acl: &sqlserverflex.CreateInstancePayloadAcl{
-//					Items: &[]string{},
-//				},
-//				Storage: &sqlserverflex.CreateInstancePayloadStorage{},
-//				Options: &sqlserverflex.CreateInstancePayloadOptions{},
-//			},
-//			true,
-//		},
-//		{
-//			"nil_options",
-//			&Model{},
-//			[]string{},
-//			&flavorModel{},
-//			&storageModel{},
-//			nil,
-//			&sqlserverflex.CreateInstancePayload{
-//				Acl: &sqlserverflex.CreateInstancePayloadAcl{
-//					Items: &[]string{},
-//				},
-//				Storage: &sqlserverflex.CreateInstancePayloadStorage{},
-//				Options: &sqlserverflex.CreateInstancePayloadOptions{},
-//			},
-//			true,
-//		},
-//	}
-//	for _, tt := range tests {
-//		t.Run(tt.description, func(t *testing.T) {
-//			output, err := toCreatePayload(tt.input, tt.inputAcl, tt.inputFlavor, tt.inputStorage, tt.inputOptions)
-//			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)
-//				}
-//			}
-//		})
-//	}
-//}
-//
-//func TestToUpdatePayload(t *testing.T) {
-//	tests := []struct {
-//		description string
-//		input       *Model
-//		inputAcl    []string
-//		inputFlavor *flavorModel
-//		expected    *sqlserverflex.PartialUpdateInstancePayload
-//		isValid     bool
-//	}{
-//		{
-//			"default_values",
-//			&Model{},
-//			[]string{},
-//			&flavorModel{},
-//			&sqlserverflex.PartialUpdateInstancePayload{
-//				Acl: &sqlserverflex.CreateInstancePayloadAcl{
-//					Items: &[]string{},
-//				},
-//			},
-//			true,
-//		},
-//		{
-//			"simple_values",
-//			&Model{
-//				BackupSchedule: types.StringValue("schedule"),
-//				Name:           types.StringValue("name"),
-//				Replicas:       types.Int64Value(12),
-//				Version:        types.StringValue("version"),
-//			},
-//			[]string{
-//				"ip_1",
-//				"ip_2",
-//			},
-//			&flavorModel{
-//				Id: types.StringValue("flavor_id"),
-//			},
-//			&sqlserverflex.PartialUpdateInstancePayload{
-//				Acl: &sqlserverflex.CreateInstancePayloadAcl{
-//					Items: &[]string{
-//						"ip_1",
-//						"ip_2",
-//					},
-//				},
-//				BackupSchedule: utils.Ptr("schedule"),
-//				FlavorId:       utils.Ptr("flavor_id"),
-//				Name:           utils.Ptr("name"),
-//				Version:        utils.Ptr("version"),
-//			},
-//			true,
-//		},
-//		{
-//			"null_fields_and_int_conversions",
-//			&Model{
-//				BackupSchedule: types.StringNull(),
-//				Name:           types.StringNull(),
-//				Replicas:       types.Int64Value(2123456789),
-//				Version:        types.StringNull(),
-//			},
-//			[]string{
-//				"",
-//			},
-//			&flavorModel{
-//				Id: types.StringNull(),
-//			},
-//			&sqlserverflex.PartialUpdateInstancePayload{
-//				Acl: &sqlserverflex.CreateInstancePayloadAcl{
-//					Items: &[]string{
-//						"",
-//					},
-//				},
-//				BackupSchedule: nil,
-//				FlavorId:       nil,
-//				Name:           nil,
-//				Version:        nil,
-//			},
-//			true,
-//		},
-//		{
-//			"nil_model",
-//			nil,
-//			[]string{},
-//			&flavorModel{},
-//			nil,
-//			false,
-//		},
-//		{
-//			"nil_acl",
-//			&Model{},
-//			nil,
-//			&flavorModel{},
-//			&sqlserverflex.PartialUpdateInstancePayload{
-//				Acl: &sqlserverflex.CreateInstancePayloadAcl{},
-//			},
-//			true,
-//		},
-//		{
-//			"nil_flavor",
-//			&Model{},
-//			[]string{},
-//			nil,
-//			nil,
-//			false,
-//		},
-//	}
-//	for _, tt := range tests {
-//		t.Run(tt.description, func(t *testing.T) {
-//			output, err := toUpdatePayload(tt.input, tt.inputAcl, tt.inputFlavor)
-//			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)
-//				}
-//			}
-//		})
-//	}
-//}
-//
-//func TestLoadFlavorId(t *testing.T) {
-//	tests := []struct {
-//		description     string
-//		inputFlavor     *flavorModel
-//		mockedResp      *sqlserverflex.ListFlavorsResponse
-//		expected        *flavorModel
-//		getFlavorsFails bool
-//		isValid         bool
-//	}{
-//		{
-//			"ok_flavor",
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			&sqlserverflex.ListFlavorsResponse{
-//				Flavors: &[]sqlserverflex.InstanceFlavorEntry{
-//					{
-//						Id:          utils.Ptr("fid-1"),
-//						Cpu:         utils.Ptr(int64(2)),
-//						Description: utils.Ptr("description"),
-//						Memory:      utils.Ptr(int64(8)),
-//					},
-//				},
-//			},
-//			&flavorModel{
-//				Id:          types.StringValue("fid-1"),
-//				Description: types.StringValue("description"),
-//				CPU:         types.Int64Value(2),
-//				RAM:         types.Int64Value(8),
-//			},
-//			false,
-//			true,
-//		},
-//		{
-//			"ok_flavor_2",
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			&sqlserverflex.ListFlavorsResponse{
-//				Flavors: &[]sqlserverflex.InstanceFlavorEntry{
-//					{
-//						Id:          utils.Ptr("fid-1"),
-//						Cpu:         utils.Ptr(int64(2)),
-//						Description: utils.Ptr("description"),
-//						Memory:      utils.Ptr(int64(8)),
-//					},
-//					{
-//						Id:          utils.Ptr("fid-2"),
-//						Cpu:         utils.Ptr(int64(1)),
-//						Description: utils.Ptr("description"),
-//						Memory:      utils.Ptr(int64(4)),
-//					},
-//				},
-//			},
-//			&flavorModel{
-//				Id:          types.StringValue("fid-1"),
-//				Description: types.StringValue("description"),
-//				CPU:         types.Int64Value(2),
-//				RAM:         types.Int64Value(8),
-//			},
-//			false,
-//			true,
-//		},
-//		{
-//			"no_matching_flavor",
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			&sqlserverflex.ListFlavorsResponse{
-//				Flavors: &[]sqlserverflex.InstanceFlavorEntry{
-//					{
-//						Id:          utils.Ptr("fid-1"),
-//						Cpu:         utils.Ptr(int64(1)),
-//						Description: utils.Ptr("description"),
-//						Memory:      utils.Ptr(int64(8)),
-//					},
-//					{
-//						Id:          utils.Ptr("fid-2"),
-//						Cpu:         utils.Ptr(int64(1)),
-//						Description: utils.Ptr("description"),
-//						Memory:      utils.Ptr(int64(4)),
-//					},
-//				},
-//			},
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			false,
-//			false,
-//		},
-//		{
-//			"nil_response",
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			&sqlserverflex.ListFlavorsResponse{},
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			false,
-//			false,
-//		},
-//		{
-//			"error_response",
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			&sqlserverflex.ListFlavorsResponse{},
-//			&flavorModel{
-//				CPU: types.Int64Value(2),
-//				RAM: types.Int64Value(8),
-//			},
-//			true,
-//			false,
-//		},
-//	}
-//	for _, tt := range tests {
-//		t.Run(tt.description, func(t *testing.T) {
-//			client := &sqlserverflexClientMocked{
-//				returnError:     tt.getFlavorsFails,
-//				listFlavorsResp: tt.mockedResp,
-//			}
-//			model := &Model{
-//				ProjectId: types.StringValue("pid"),
-//			}
-//			flavorModel := &flavorModel{
-//				CPU: tt.inputFlavor.CPU,
-//				RAM: tt.inputFlavor.RAM,
-//			}
-//			err := loadFlavorId(context.Background(), client, model, flavorModel)
-//			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(flavorModel, tt.expected)
-//				if diff != "" {
-//					t.Fatalf("Data does not match: %s", diff)
-//				}
-//			}
-//		})
-//	}
-//}

stackit/internal/services/sqlserverflexalpha/sqlserverflex_acc_test.go

@@ -1,482 +1,396 @@
-// Copyright (c) STACKIT
-
-package sqlserverflex_test
+package sqlserverflexalpha_test
 
 import (
 	"context"
 	_ "embed"
 	"fmt"
-	"maps"
-	"strings"
+	"os"
+	"strconv"
 	"testing"
 
-	"github.com/hashicorp/terraform-plugin-testing/config"
 	"github.com/hashicorp/terraform-plugin-testing/helper/acctest"
 	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
-	"github.com/hashicorp/terraform-plugin-testing/terraform"
-	core_config "github.com/stackitcloud/stackit-sdk-go/core/config"
-	"github.com/stackitcloud/stackit-sdk-go/core/utils"
-	"github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex"
-	"github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/wait"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/testutil"
+
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/internal/testutils"
+	sqlserverflexalpha "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/instance"
+
+	// The fwresource import alias is so there is no collision
+	// with the more typical acceptance testing import:
+	// "github.com/hashicorp/terraform-plugin-testing/helper/resource"
+	fwresource "github.com/hashicorp/terraform-plugin-framework/resource"
 )
 
-var (
-	//go:embed testdata/resource-max.tf
-	resourceMaxConfig string
-	//go:embed testdata/resource-min.tf
-	resourceMinConfig string
-)
-var testConfigVarsMin = config.Variables{
-	"project_id":         config.StringVariable(testutil.ProjectId),
-	"name":               config.StringVariable(fmt.Sprintf("tf-acc-%s", acctest.RandStringFromCharSet(7, acctest.CharSetAlphaNum))),
-	"flavor_cpu":         config.IntegerVariable(4),
-	"flavor_ram":         config.IntegerVariable(16),
-	"flavor_description": config.StringVariable("SQLServer-Flex-4.16-Standard-EU01"),
-	"replicas":           config.IntegerVariable(1),
-	"flavor_id":          config.StringVariable("4.16-Single"),
-	"username":           config.StringVariable(fmt.Sprintf("tf-acc-user-%s", acctest.RandStringFromCharSet(7, acctest.CharSetAlpha))),
-	"role":               config.StringVariable("##STACKIT_LoginManager##"),
-}
+const providerPrefix = "stackitprivatepreview_sqlserverflexalpha"
 
-var testConfigVarsMax = config.Variables{
-	"project_id":             config.StringVariable(testutil.ProjectId),
-	"name":                   config.StringVariable(fmt.Sprintf("tf-acc-%s", acctest.RandStringFromCharSet(7, acctest.CharSetAlphaNum))),
-	"acl1":                   config.StringVariable("192.168.0.0/16"),
-	"flavor_cpu":             config.IntegerVariable(4),
-	"flavor_ram":             config.IntegerVariable(16),
-	"flavor_description":     config.StringVariable("SQLServer-Flex-4.16-Standard-EU01"),
-	"storage_class":          config.StringVariable("premium-perf2-stackit"),
-	"storage_size":           config.IntegerVariable(40),
-	"server_version":         config.StringVariable("2022"),
-	"replicas":               config.IntegerVariable(1),
-	"options_retention_days": config.IntegerVariable(64),
-	"flavor_id":              config.StringVariable("4.16-Single"),
-	"backup_schedule":        config.StringVariable("00 6 * * *"),
-	"username":               config.StringVariable(fmt.Sprintf("tf-acc-user-%s", acctest.RandStringFromCharSet(7, acctest.CharSetAlpha))),
-	"role":                   config.StringVariable("##STACKIT_LoginManager##"),
-	"region":                 config.StringVariable(testutil.Region),
-}
+var testInstances []string
 
-func configVarsMinUpdated() config.Variables {
-	temp := maps.Clone(testConfigVarsMax)
-	temp["name"] = config.StringVariable(testutil.ConvertConfigVariable(temp["name"]) + "changed")
-	return temp
-}
+func TestInstanceResourceSchema(t *testing.T) {
+	t.Parallel()
 
-func configVarsMaxUpdated() config.Variables {
-	temp := maps.Clone(testConfigVarsMax)
-	temp["backup_schedule"] = config.StringVariable("00 12 * * *")
-	return temp
-}
-
-func TestAccSQLServerFlexMinResource(t *testing.T) {
-	resource.Test(t, resource.TestCase{
-		ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
-		CheckDestroy:             testAccChecksqlserverflexDestroy,
-		Steps: []resource.TestStep{
-			// Creation
-			{
-				Config:          testutil.SQLServerFlexProviderConfig() + "\n" + resourceMinConfig,
-				ConfigVariables: testConfigVarsMin,
-				Check: resource.ComposeAggregateTestCheckFunc(
-					// Instance
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "project_id", testutil.ConvertConfigVariable(testConfigVarsMin["project_id"])),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_instance.instance", "instance_id"),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "name", testutil.ConvertConfigVariable(testConfigVarsMin["name"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "acl.#", "1"),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_instance.instance", "flavor.id"),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "flavor.description", testutil.ConvertConfigVariable(testConfigVarsMin["flavor_description"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "replicas", testutil.ConvertConfigVariable(testConfigVarsMin["replicas"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "flavor.cpu", testutil.ConvertConfigVariable(testConfigVarsMin["flavor_cpu"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "flavor.ram", testutil.ConvertConfigVariable(testConfigVarsMin["flavor_ram"])),
-					// User
-					resource.TestCheckResourceAttrPair(
-						"stackit_sqlserverflex_user.user", "project_id",
-						"stackit_sqlserverflex_instance.instance", "project_id",
-					),
-					resource.TestCheckResourceAttrPair(
-						"stackit_sqlserverflex_user.user", "instance_id",
-						"stackit_sqlserverflex_instance.instance", "instance_id",
-					),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_user.user", "user_id"),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_user.user", "password"),
-				),
-			},
-			// Update
-			{
-				Config:          testutil.SQLServerFlexProviderConfig() + "\n" + resourceMinConfig,
-				ConfigVariables: testConfigVarsMin,
-				Check: resource.ComposeAggregateTestCheckFunc(
-					// Instance
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "project_id", testutil.ConvertConfigVariable(testConfigVarsMin["project_id"])),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_instance.instance", "instance_id"),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "name", testutil.ConvertConfigVariable(testConfigVarsMin["name"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "acl.#", "1"),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_instance.instance", "flavor.id"),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "flavor.description", testutil.ConvertConfigVariable(testConfigVarsMin["flavor_description"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "flavor.cpu", testutil.ConvertConfigVariable(testConfigVarsMin["flavor_cpu"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "flavor.ram", testutil.ConvertConfigVariable(testConfigVarsMin["flavor_ram"])),
-					// User
-					resource.TestCheckResourceAttrPair(
-						"stackit_sqlserverflex_user.user", "project_id",
-						"stackit_sqlserverflex_instance.instance", "project_id",
-					),
-					resource.TestCheckResourceAttrPair(
-						"stackit_sqlserverflex_user.user", "instance_id",
-						"stackit_sqlserverflex_instance.instance", "instance_id",
-					),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_user.user", "user_id"),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_user.user", "password"),
-				),
-			},
-			// data source
-			{
-				Config:          testutil.SQLServerFlexProviderConfig() + "\n" + resourceMinConfig,
-				ConfigVariables: testConfigVarsMin,
-				Check: resource.ComposeAggregateTestCheckFunc(
-					// Instance data
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_instance.instance", "project_id", testutil.ConvertConfigVariable(testConfigVarsMin["project_id"])),
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_instance.instance", "name", testutil.ConvertConfigVariable(testConfigVarsMin["name"])),
-					resource.TestCheckResourceAttrPair(
-						"data.stackit_sqlserverflex_instance.instance", "project_id",
-						"stackit_sqlserverflex_instance.instance", "project_id",
-					),
-					resource.TestCheckResourceAttrPair(
-						"data.stackit_sqlserverflex_instance.instance", "instance_id",
-						"stackit_sqlserverflex_instance.instance", "instance_id",
-					),
-					resource.TestCheckResourceAttrPair(
-						"data.stackit_sqlserverflex_user.user", "instance_id",
-						"stackit_sqlserverflex_user.user", "instance_id",
-					),
-
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_instance.instance", "acl.#", "1"),
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_instance.instance", "flavor.id", testutil.ConvertConfigVariable(testConfigVarsMin["flavor_id"])),
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_instance.instance", "flavor.description", testutil.ConvertConfigVariable(testConfigVarsMin["flavor_description"])),
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_instance.instance", "flavor.cpu", testutil.ConvertConfigVariable(testConfigVarsMin["flavor_cpu"])),
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_instance.instance", "flavor.ram", testutil.ConvertConfigVariable(testConfigVarsMin["flavor_ram"])),
-
-					// User data
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_user.user", "project_id", testutil.ConvertConfigVariable(testConfigVarsMin["project_id"])),
-					resource.TestCheckResourceAttrSet("data.stackit_sqlserverflex_user.user", "user_id"),
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_user.user", "username", testutil.ConvertConfigVariable(testConfigVarsMin["username"])),
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_user.user", "roles.#", "1"),
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_user.user", "roles.0", testutil.ConvertConfigVariable(testConfigVarsMax["role"])),
-				),
-			},
-			// Import
-			{
-				ConfigVariables: testConfigVarsMin,
-				ResourceName:    "stackit_sqlserverflex_instance.instance",
-				ImportStateIdFunc: func(s *terraform.State) (string, error) {
-					r, ok := s.RootModule().Resources["stackit_sqlserverflex_instance.instance"]
-					if !ok {
-						return "", fmt.Errorf("couldn't find resource stackit_sqlserverflex_instance.instance")
-					}
-					instanceId, ok := r.Primary.Attributes["instance_id"]
-					if !ok {
-						return "", fmt.Errorf("couldn't find attribute instance_id")
-					}
-
-					return fmt.Sprintf("%s,%s,%s", testutil.ProjectId, testutil.Region, instanceId), nil
-				},
-				ImportState:             true,
-				ImportStateVerify:       true,
-				ImportStateVerifyIgnore: []string{"backup_schedule"},
-				ImportStateCheck: func(s []*terraform.InstanceState) error {
-					if len(s) != 1 {
-						return fmt.Errorf("expected 1 state, got %d", len(s))
-					}
-					return nil
-				},
-			},
-			{
-				ResourceName:    "stackit_sqlserverflex_user.user",
-				ConfigVariables: testConfigVarsMin,
-				ImportStateIdFunc: func(s *terraform.State) (string, error) {
-					r, ok := s.RootModule().Resources["stackit_sqlserverflex_user.user"]
-					if !ok {
-						return "", fmt.Errorf("couldn't find resource stackit_sqlserverflex_user.user")
-					}
-					instanceId, ok := r.Primary.Attributes["instance_id"]
-					if !ok {
-						return "", fmt.Errorf("couldn't find attribute instance_id")
-					}
-					userId, ok := r.Primary.Attributes["user_id"]
-					if !ok {
-						return "", fmt.Errorf("couldn't find attribute user_id")
-					}
-
-					return fmt.Sprintf("%s,%s,%s,%s", testutil.ProjectId, testutil.Region, instanceId, userId), nil
-				},
-				ImportState:             true,
-				ImportStateVerify:       true,
-				ImportStateVerifyIgnore: []string{"password"},
-			},
-			// Update
-			{
-				Config:          testutil.SQLServerFlexProviderConfig() + "\n" + resourceMinConfig,
-				ConfigVariables: configVarsMinUpdated(),
-				Check: resource.ComposeAggregateTestCheckFunc(
-					// Instance data
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "project_id", testutil.ConvertConfigVariable(configVarsMinUpdated()["project_id"])),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_instance.instance", "instance_id"),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "name", testutil.ConvertConfigVariable(configVarsMinUpdated()["name"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "acl.#", "1"),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_instance.instance", "flavor.id"),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_instance.instance", "flavor.description"),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "flavor.cpu", testutil.ConvertConfigVariable(configVarsMinUpdated()["flavor_cpu"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "flavor.ram", testutil.ConvertConfigVariable(configVarsMinUpdated()["flavor_ram"])),
-				),
-			},
-			// Deletion is done by the framework implicitly
-		},
-	})
-}
-
-func TestAccSQLServerFlexMaxResource(t *testing.T) {
-	resource.Test(t, resource.TestCase{
-		ProtoV6ProviderFactories: testutil.TestAccProtoV6ProviderFactories,
-		CheckDestroy:             testAccChecksqlserverflexDestroy,
-		Steps: []resource.TestStep{
-			// Creation
-			{
-				Config:          testutil.SQLServerFlexProviderConfig() + "\n" + resourceMaxConfig,
-				ConfigVariables: testConfigVarsMax,
-				Check: resource.ComposeAggregateTestCheckFunc(
-					// Instance
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "project_id", testutil.ConvertConfigVariable(testConfigVarsMax["project_id"])),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_instance.instance", "instance_id"),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "name", testutil.ConvertConfigVariable(testConfigVarsMax["name"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "acl.#", "1"),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "acl.0", testutil.ConvertConfigVariable(testConfigVarsMax["acl1"])),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_instance.instance", "flavor.id"),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "flavor.description", testutil.ConvertConfigVariable(testConfigVarsMax["flavor_description"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "replicas", testutil.ConvertConfigVariable(testConfigVarsMax["replicas"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "flavor.cpu", testutil.ConvertConfigVariable(testConfigVarsMax["flavor_cpu"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "flavor.ram", testutil.ConvertConfigVariable(testConfigVarsMax["flavor_ram"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "storage.class", testutil.ConvertConfigVariable(testConfigVarsMax["storage_class"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "storage.size", testutil.ConvertConfigVariable(testConfigVarsMax["storage_size"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "version", testutil.ConvertConfigVariable(testConfigVarsMax["server_version"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "options.retention_days", testutil.ConvertConfigVariable(testConfigVarsMax["options_retention_days"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "backup_schedule", testutil.ConvertConfigVariable(testConfigVarsMax["backup_schedule"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "region", testutil.Region),
-					// User
-					resource.TestCheckResourceAttrPair(
-						"stackit_sqlserverflex_user.user", "project_id",
-						"stackit_sqlserverflex_instance.instance", "project_id",
-					),
-					resource.TestCheckResourceAttrPair(
-						"stackit_sqlserverflex_user.user", "instance_id",
-						"stackit_sqlserverflex_instance.instance", "instance_id",
-					),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_user.user", "user_id"),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_user.user", "password"),
-				),
-			},
-			// Update
-			{
-				Config:          testutil.SQLServerFlexProviderConfig() + "\n" + resourceMaxConfig,
-				ConfigVariables: testConfigVarsMax,
-				Check: resource.ComposeAggregateTestCheckFunc(
-					// Instance
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "project_id", testutil.ConvertConfigVariable(testConfigVarsMax["project_id"])),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_instance.instance", "instance_id"),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "name", testutil.ConvertConfigVariable(testConfigVarsMax["name"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "acl.#", "1"),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "acl.0", testutil.ConvertConfigVariable(testConfigVarsMax["acl1"])),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_instance.instance", "flavor.id"),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "flavor.description", testutil.ConvertConfigVariable(testConfigVarsMax["flavor_description"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "replicas", testutil.ConvertConfigVariable(testConfigVarsMax["replicas"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "flavor.cpu", testutil.ConvertConfigVariable(testConfigVarsMax["flavor_cpu"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "flavor.ram", testutil.ConvertConfigVariable(testConfigVarsMax["flavor_ram"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "storage.class", testutil.ConvertConfigVariable(testConfigVarsMax["storage_class"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "storage.size", testutil.ConvertConfigVariable(testConfigVarsMax["storage_size"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "version", testutil.ConvertConfigVariable(testConfigVarsMax["server_version"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "options.retention_days", testutil.ConvertConfigVariable(testConfigVarsMax["options_retention_days"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "backup_schedule", testutil.ConvertConfigVariable(testConfigVarsMax["backup_schedule"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "region", testutil.Region),
-					// User
-					resource.TestCheckResourceAttrPair(
-						"stackit_sqlserverflex_user.user", "project_id",
-						"stackit_sqlserverflex_instance.instance", "project_id",
-					),
-					resource.TestCheckResourceAttrPair(
-						"stackit_sqlserverflex_user.user", "instance_id",
-						"stackit_sqlserverflex_instance.instance", "instance_id",
-					),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_user.user", "user_id"),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_user.user", "password"),
-				),
-			},
-			// data source
-			{
-				Config:          testutil.SQLServerFlexProviderConfig() + "\n" + resourceMaxConfig,
-				ConfigVariables: testConfigVarsMax,
-				Check: resource.ComposeAggregateTestCheckFunc(
-					// Instance data
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_instance.instance", "project_id", testutil.ConvertConfigVariable(testConfigVarsMax["project_id"])),
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_instance.instance", "name", testutil.ConvertConfigVariable(testConfigVarsMax["name"])),
-					resource.TestCheckResourceAttrPair(
-						"data.stackit_sqlserverflex_instance.instance", "project_id",
-						"stackit_sqlserverflex_instance.instance", "project_id",
-					),
-					resource.TestCheckResourceAttrPair(
-						"data.stackit_sqlserverflex_instance.instance", "instance_id",
-						"stackit_sqlserverflex_instance.instance", "instance_id",
-					),
-					resource.TestCheckResourceAttrPair(
-						"data.stackit_sqlserverflex_user.user", "instance_id",
-						"stackit_sqlserverflex_user.user", "instance_id",
-					),
-
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_instance.instance", "acl.#", "1"),
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_instance.instance", "acl.0", testutil.ConvertConfigVariable(testConfigVarsMax["acl1"])),
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_instance.instance", "flavor.id", testutil.ConvertConfigVariable(testConfigVarsMax["flavor_id"])),
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_instance.instance", "flavor.description", testutil.ConvertConfigVariable(testConfigVarsMax["flavor_description"])),
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_instance.instance", "flavor.cpu", testutil.ConvertConfigVariable(testConfigVarsMax["flavor_cpu"])),
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_instance.instance", "flavor.ram", testutil.ConvertConfigVariable(testConfigVarsMax["flavor_ram"])),
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_instance.instance", "replicas", testutil.ConvertConfigVariable(testConfigVarsMax["replicas"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "options.retention_days", testutil.ConvertConfigVariable(testConfigVarsMax["options_retention_days"])),
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_instance.instance", "backup_schedule", testutil.ConvertConfigVariable(testConfigVarsMax["backup_schedule"])),
-
-					// User data
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_user.user", "project_id", testutil.ConvertConfigVariable(testConfigVarsMax["project_id"])),
-					resource.TestCheckResourceAttrSet("data.stackit_sqlserverflex_user.user", "user_id"),
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_user.user", "username", testutil.ConvertConfigVariable(testConfigVarsMax["username"])),
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_user.user", "roles.#", "1"),
-					resource.TestCheckResourceAttr("data.stackit_sqlserverflex_user.user", "roles.0", testutil.ConvertConfigVariable(testConfigVarsMax["role"])),
-					resource.TestCheckResourceAttrSet("data.stackit_sqlserverflex_user.user", "host"),
-					resource.TestCheckResourceAttrSet("data.stackit_sqlserverflex_user.user", "port"),
-				),
-			},
-			// Import
-			{
-				ConfigVariables: testConfigVarsMax,
-				ResourceName:    "stackit_sqlserverflex_instance.instance",
-				ImportStateIdFunc: func(s *terraform.State) (string, error) {
-					r, ok := s.RootModule().Resources["stackit_sqlserverflex_instance.instance"]
-					if !ok {
-						return "", fmt.Errorf("couldn't find resource stackit_sqlserverflex_instance.instance")
-					}
-					instanceId, ok := r.Primary.Attributes["instance_id"]
-					if !ok {
-						return "", fmt.Errorf("couldn't find attribute instance_id")
-					}
-
-					return fmt.Sprintf("%s,%s,%s", testutil.ProjectId, testutil.Region, instanceId), nil
-				},
-				ImportState:             true,
-				ImportStateVerify:       true,
-				ImportStateVerifyIgnore: []string{"backup_schedule"},
-				ImportStateCheck: func(s []*terraform.InstanceState) error {
-					if len(s) != 1 {
-						return fmt.Errorf("expected 1 state, got %d", len(s))
-					}
-					if s[0].Attributes["backup_schedule"] != testutil.ConvertConfigVariable(testConfigVarsMax["backup_schedule"]) {
-						return fmt.Errorf("expected backup_schedule %s, got %s", testConfigVarsMax["backup_schedule"], s[0].Attributes["backup_schedule"])
-					}
-					return nil
-				},
-			},
-			{
-				ResourceName:    "stackit_sqlserverflex_user.user",
-				ConfigVariables: testConfigVarsMax,
-				ImportStateIdFunc: func(s *terraform.State) (string, error) {
-					r, ok := s.RootModule().Resources["stackit_sqlserverflex_user.user"]
-					if !ok {
-						return "", fmt.Errorf("couldn't find resource stackit_sqlserverflex_user.user")
-					}
-					instanceId, ok := r.Primary.Attributes["instance_id"]
-					if !ok {
-						return "", fmt.Errorf("couldn't find attribute instance_id")
-					}
-					userId, ok := r.Primary.Attributes["user_id"]
-					if !ok {
-						return "", fmt.Errorf("couldn't find attribute user_id")
-					}
-
-					return fmt.Sprintf("%s,%s,%s,%s", testutil.ProjectId, testutil.Region, instanceId, userId), nil
-				},
-				ImportState:             true,
-				ImportStateVerify:       true,
-				ImportStateVerifyIgnore: []string{"password"},
-			},
-			// Update
-			{
-				Config:          testutil.SQLServerFlexProviderConfig() + "\n" + resourceMaxConfig,
-				ConfigVariables: configVarsMaxUpdated(),
-				Check: resource.ComposeAggregateTestCheckFunc(
-					// Instance data
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "project_id", testutil.ConvertConfigVariable(configVarsMaxUpdated()["project_id"])),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_instance.instance", "instance_id"),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "name", testutil.ConvertConfigVariable(configVarsMaxUpdated()["name"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "acl.#", "1"),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "acl.0", testutil.ConvertConfigVariable(configVarsMaxUpdated()["acl1"])),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_instance.instance", "flavor.id"),
-					resource.TestCheckResourceAttrSet("stackit_sqlserverflex_instance.instance", "flavor.description"),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "flavor.cpu", testutil.ConvertConfigVariable(configVarsMaxUpdated()["flavor_cpu"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "flavor.ram", testutil.ConvertConfigVariable(configVarsMaxUpdated()["flavor_ram"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "replicas", testutil.ConvertConfigVariable(configVarsMaxUpdated()["replicas"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "storage.class", testutil.ConvertConfigVariable(configVarsMaxUpdated()["storage_class"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "storage.size", testutil.ConvertConfigVariable(configVarsMaxUpdated()["storage_size"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "version", testutil.ConvertConfigVariable(configVarsMaxUpdated()["server_version"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "options.retention_days", testutil.ConvertConfigVariable(configVarsMaxUpdated()["options_retention_days"])),
-					resource.TestCheckResourceAttr("stackit_sqlserverflex_instance.instance", "backup_schedule", testutil.ConvertConfigVariable(configVarsMaxUpdated()["backup_schedule"])),
-				),
-			},
-			// Deletion is done by the framework implicitly
-		},
-	})
-}
-
-func testAccChecksqlserverflexDestroy(s *terraform.State) error {
 	ctx := context.Background()
-	var client *sqlserverflex.APIClient
-	var err error
-	if testutil.SQLServerFlexCustomEndpoint == "" {
-		client, err = sqlserverflex.NewAPIClient()
-	} else {
-		client, err = sqlserverflex.NewAPIClient(
-			core_config.WithEndpoint(testutil.SQLServerFlexCustomEndpoint),
-		)
-	}
-	if err != nil {
-		return fmt.Errorf("creating client: %w", err)
+	schemaRequest := fwresource.SchemaRequest{}
+	schemaResponse := &fwresource.SchemaResponse{}
+
+	// Instantiate the resource.Resource and call its Schema method
+	sqlserverflexalpha.NewInstanceResource().Schema(ctx, schemaRequest, schemaResponse)
+
+	if schemaResponse.Diagnostics.HasError() {
+		t.Fatalf("Schema method diagnostics: %+v", schemaResponse.Diagnostics)
 	}
 
-	instancesToDestroy := []string{}
-	for _, rs := range s.RootModule().Resources {
-		if rs.Type != "stackit_sqlserverflex_instance" {
-			continue
-		}
-		// instance terraform ID: = "[project_id],[region],[instance_id]"
-		instanceId := strings.Split(rs.Primary.ID, core.Separator)[2]
-		instancesToDestroy = append(instancesToDestroy, instanceId)
-	}
+	// Validate the schema
+	diagnostics := schemaResponse.Schema.ValidateImplementation(ctx)
 
-	instancesResp, err := client.ListInstances(ctx, testutil.ProjectId, testutil.Region).Execute()
-	if err != nil {
-		return fmt.Errorf("getting instancesResp: %w", err)
+	if diagnostics.HasError() {
+		t.Fatalf("Schema validation diagnostics: %+v", diagnostics)
 	}
-
-	items := *instancesResp.Items
-	for i := range items {
-		if items[i].Id == nil {
-			continue
-		}
-		if utils.Contains(instancesToDestroy, *items[i].Id) {
-			err := client.DeleteInstanceExecute(ctx, testutil.ProjectId, *items[i].Id, testutil.Region)
-			if err != nil {
-				return fmt.Errorf("destroying instance %s during CheckDestroy: %w", *items[i].Id, err)
-			}
-			_, err = wait.DeleteInstanceWaitHandler(ctx, client, testutil.ProjectId, *items[i].Id, testutil.Region).WaitWithContext(ctx)
-			if err != nil {
-				return fmt.Errorf("destroying instance %s during CheckDestroy: waiting for deletion %w", *items[i].Id, err)
-			}
-		}
-	}
-	return nil
+}
+
+func TestMain(m *testing.M) {
+	testutils.Setup()
+	code := m.Run()
+	// shutdown()
+	os.Exit(code)
+}
+
+func testAccPreCheck(t *testing.T) {
+	if _, ok := os.LookupEnv("TF_ACC_PROJECT_ID"); !ok {
+		t.Fatalf("could not find env var TF_ACC_PROJECT_ID")
+	}
+}
+
+type resData struct {
+	ServiceAccountFilePath string
+	ProjectID              string
+	Region                 string
+	Name                   string
+	TfName                 string
+	FlavorID               string
+	BackupSchedule         string
+	UseEncryption          bool
+	KekKeyID               string
+	KekKeyRingID           string
+	KekKeyVersion          uint8
+	KekServiceAccount      string
+	PerformanceClass       string
+	Size                   uint32
+	ACLString              string
+	AccessScope            string
+	RetentionDays          uint32
+	Version                string
+	Users                  []User
+	Databases              []Database
+}
+
+type User struct {
+	Name      string
+	ProjectID string
+	Roles     []string
+}
+
+type Database struct {
+	Name          string
+	ProjectID     string
+	Owner         string
+	Collation     string
+	Compatibility string
+}
+
+func resName(res, name string) string {
+	return fmt.Sprintf("%s_%s.%s", providerPrefix, res, name)
+}
+
+func getExample() resData {
+	name := acctest.RandomWithPrefix("tf-acc")
+	return resData{
+		Region:                 os.Getenv("TF_ACC_REGION"),
+		ServiceAccountFilePath: os.Getenv("TF_ACC_SERVICE_ACCOUNT_FILE"),
+		ProjectID:              os.Getenv("TF_ACC_PROJECT_ID"),
+		Name:                   name,
+		TfName:                 name,
+		FlavorID:               "4.16-Single",
+		BackupSchedule:         "0 0 * * *",
+		UseEncryption:          false,
+		RetentionDays:          33,
+		PerformanceClass:       "premium-perf2-stackit",
+		Size:                   10,
+		ACLString:              "0.0.0.0/0",
+		AccessScope:            "PUBLIC",
+		Version:                "2022",
+	}
+}
+
+func TestAccInstance(t *testing.T) {
+	exData := getExample()
+
+	updNameData := exData
+	updNameData.Name = "name-updated"
+
+	updSizeData := exData
+	updSizeData.Size = 25
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			t.Logf("  ... working on instance %s", exData.TfName)
+			testInstances = append(testInstances, exData.TfName)
+		},
+		ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
+		Steps: []resource.TestStep{
+			// Create and verify
+			{
+				Config: testutils.StringFromTemplateMust(
+					"testdata/instance_template.gompl",
+					exData,
+				),
+				Check: resource.ComposeAggregateTestCheckFunc(
+					resource.TestCheckResourceAttr(resName("instance", exData.TfName), "name", exData.Name),
+					resource.TestCheckResourceAttrSet(resName("instance", exData.TfName), "id"),
+					// TODO: check all fields
+				),
+			},
+			// Update name and verify
+			{
+				Config: testutils.StringFromTemplateMust(
+					"testdata/instance_template.gompl",
+					updNameData,
+				),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(resName("instance", exData.TfName), "name", updNameData.Name),
+				),
+			},
+			// Update size and verify
+			{
+				Config: testutils.StringFromTemplateMust(
+					"testdata/instance_template.gompl",
+					updSizeData,
+				),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(
+						testutils.ResStr(providerPrefix, "instance", exData.TfName),
+						"storage.size",
+						strconv.Itoa(int(updSizeData.Size)),
+					),
+				),
+			},
+			{
+				RefreshState: true,
+			},
+			//// Import test
+			//{
+			//	ResourceName:      resName("instance", exData.TfName),
+			//	ImportState:       true,
+			//	ImportStateVerify: true,
+			// },
+		},
+	})
+}
+
+func TestAccInstanceNoEncryption(t *testing.T) {
+	data := getExample()
+
+	dbName := "testDb"
+	userName := "testUser"
+	data.Users = []User{
+		{
+			Name:      userName,
+			ProjectID: os.Getenv("TF_ACC_PROJECT_ID"),
+			Roles: []string{
+				"##STACKIT_DatabaseManager##",
+				"##STACKIT_LoginManager##",
+				//"##STACKIT_ProcessManager##",
+				//"##STACKIT_SQLAgentManager##",
+				//"##STACKIT_SQLAgentUser##",
+				//"##STACKIT_ServerManager##",
+			},
+		},
+	}
+	data.Databases = []Database{
+		{
+			Name:      dbName,
+			ProjectID: os.Getenv("TF_ACC_PROJECT_ID"),
+			Owner:     userName,
+		},
+	}
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			t.Logf("  ... working on instance %s", data.TfName)
+			testInstances = append(testInstances, data.TfName)
+		},
+		ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
+		Steps: []resource.TestStep{
+			// Create and verify
+			{
+				Config: testutils.StringFromTemplateMust(
+					"testdata/instance_template.gompl",
+					data,
+				),
+				Check: resource.ComposeAggregateTestCheckFunc(
+					// check instance values are set
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "id"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "backup_schedule"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "edition"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "flavor_id"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "instance_id"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "is_deletable"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "name"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "replicas"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "retention_days"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "status"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "version"),
+
+					resource.TestCheckNoResourceAttr(resName("instance", data.TfName), "encryption"),
+
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "encryption"),
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "encryption.kek_key_id"),
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "encryption.kek_key_version"),
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "encryption.kek_key_ring_id"),
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "encryption.service_account"),
+
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "network.access_scope"),
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "network.acl"),
+
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "network.instance_address"),
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "network.router_address"),
+
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "storage.class"),
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "storage.size"),
+
+					// check instance values are correct
+					resource.TestCheckResourceAttr(resName("instance", data.TfName), "name", data.Name),
+
+					// check user values are set
+					resource.TestCheckResourceAttrSet(resName("user", userName), "id"),
+					resource.TestCheckResourceAttrSet(resName("user", userName), "username"),
+					// resource.TestCheckResourceAttrSet(resName("user", userName), "roles"),
+
+					// func(s *terraform.State) error {
+					//	return nil
+					// },
+
+					// check user values are correct
+					resource.TestCheckResourceAttr(resName("user", userName), "username", userName),
+					resource.TestCheckResourceAttr(resName("user", userName), "roles.#", strconv.Itoa(len(data.Users[0].Roles))),
+
+					// check database values are set
+					resource.TestCheckResourceAttrSet(resName("database", dbName), "id"),
+					resource.TestCheckResourceAttrSet(resName("database", dbName), "name"),
+					resource.TestCheckResourceAttrSet(resName("database", dbName), "owner"),
+					resource.TestCheckResourceAttrSet(resName("database", dbName), "compatibility"),
+					resource.TestCheckResourceAttrSet(resName("database", dbName), "collation"),
+
+					// check database values are correct
+					resource.TestCheckResourceAttr(resName("database", dbName), "name", dbName),
+					resource.TestCheckResourceAttr(resName("database", dbName), "owner", userName),
+				),
+			},
+		},
+	})
+}
+
+func TestAccInstanceEncryption(t *testing.T) {
+	data := getExample()
+
+	dbName := "testDb"
+	userName := "testUser"
+	data.Users = []User{
+		{
+			Name:      userName,
+			ProjectID: os.Getenv("TF_ACC_PROJECT_ID"),
+			Roles:     []string{"##STACKIT_DatabaseManager##", "##STACKIT_LoginManager##"},
+		},
+	}
+	data.Databases = []Database{
+		{
+			Name:      dbName,
+			ProjectID: os.Getenv("TF_ACC_PROJECT_ID"),
+			Owner:     userName,
+		},
+	}
+
+	data.UseEncryption = true
+	data.KekKeyID = os.Getenv("TF_ACC_KEK_KEY_ID")
+	data.KekKeyRingID = os.Getenv("TF_ACC_KEK_KEY_RING_ID")
+	verString := os.Getenv("TF_ACC_KEK_KEY_VERSION")
+	version, err := strconv.ParseInt(verString, 0, 32)
+	if err != nil {
+		t.Errorf("error coverting value to uint8: %+v", verString)
+	}
+	data.KekKeyVersion = uint8(version) //nolint:gosec // not important its a test
+	data.KekServiceAccount = os.Getenv("TF_ACC_KEK_SERVICE_ACCOUNT")
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck: func() {
+			testAccPreCheck(t)
+			t.Logf("  ... working on instance %s", data.TfName)
+			testInstances = append(testInstances, data.TfName)
+		},
+		ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
+		Steps: []resource.TestStep{
+			// Create and verify
+			{
+				Config: testutils.StringFromTemplateMust(
+					"testdata/instance_template.gompl",
+					data,
+				),
+				Check: resource.ComposeAggregateTestCheckFunc(
+					// check instance values are set
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "id"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "backup_schedule"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "edition"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "flavor_id"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "instance_id"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "is_deletable"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "name"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "replicas"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "retention_days"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "status"),
+					resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "version"),
+
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "encryption"),
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "encryption.kek_key_id"),
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "encryption.kek_key_version"),
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "encryption.kek_key_ring_id"),
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "encryption.service_account"),
+
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "network.access_scope"),
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "network.acl"),
+
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "network.instance_address"),
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "network.router_address"),
+
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "storage.class"),
+					// resource.TestCheckResourceAttrSet(resName("instance", data.TfName), "storage.size"),
+
+					// check instance values are correct
+					resource.TestCheckResourceAttr(resName("instance", data.TfName), "name", data.Name),
+
+					// check user values are set
+					resource.TestCheckResourceAttrSet(resName("user", userName), "id"),
+					resource.TestCheckResourceAttrSet(resName("user", userName), "username"),
+
+					// func(s *terraform.State) error {
+					//	return nil
+					// },
+
+					// check user values are correct
+					resource.TestCheckResourceAttr(resName("user", userName), "username", userName),
+					resource.TestCheckResourceAttr(resName("user", userName), "roles.#", "2"),
+
+					// check database values are set
+					resource.TestCheckResourceAttrSet(resName("database", dbName), "id"),
+					resource.TestCheckResourceAttrSet(resName("database", dbName), "name"),
+					resource.TestCheckResourceAttrSet(resName("database", dbName), "owner"),
+					resource.TestCheckResourceAttrSet(resName("database", dbName), "compatibility"),
+					resource.TestCheckResourceAttrSet(resName("database", dbName), "collation"),
+
+					// check database values are correct
+					resource.TestCheckResourceAttr(resName("database", dbName), "name", dbName),
+					resource.TestCheckResourceAttr(resName("database", dbName), "owner", userName),
+				),
+			},
+		},
+	})
 }

stackit/internal/services/sqlserverflexalpha/testdata/instance_template.gompl

@@ -0,0 +1,60 @@
+provider "stackitprivatepreview" {
+    default_region = "{{ .Region }}"
+    service_account_key_path = "{{ .ServiceAccountFilePath }}"
+}
+
+resource "stackitprivatepreview_sqlserverflexalpha_instance" "{{ .TfName }}" {
+  project_id      = "{{ .ProjectID }}"
+  name            = "{{ .Name }}"
+  backup_schedule = "{{ .BackupSchedule }}"
+  retention_days  = {{ .RetentionDays }}
+  flavor_id       = "{{ .FlavorID }}"
+  storage = {
+    class = "{{ .PerformanceClass }}"
+    size              = {{ .Size }}
+  }
+{{ if .UseEncryption }}
+  encryption = {
+    kek_key_id      = "{{ .KekKeyID }}"
+    kek_key_ring_id = "{{ .KekKeyRingID }}"
+    kek_key_version = {{ .KekKeyVersion }}
+    service_account = "{{ .KekServiceAccount }}"
+  }
+{{ end }}
+  network = {
+    acl          = ["{{ .ACLString }}"]
+    access_scope = "{{ .AccessScope }}"
+  }
+  version = "{{ .Version }}"
+}
+
+{{ if .Users }}
+{{ $tfName := .TfName }}
+{{ range $user := .Users }}
+resource "stackitprivatepreview_sqlserverflexalpha_user" "{{ $user.Name }}" {
+  project_id  = "{{ $user.ProjectID }}"
+  instance_id = stackitprivatepreview_sqlserverflexalpha_instance.{{ $tfName }}.instance_id
+  username    = "{{ $user.Name }}"
+  roles       = [{{ range $i, $v := $user.Roles }}{{if $i}},{{end}}"{{$v}}"{{end}}]
+}
+{{ end }}
+{{ end }}
+
+{{ if .Databases }}
+{{ $tfName := .TfName }}
+{{ range $db := .Databases }}
+resource "stackitprivatepreview_sqlserverflexalpha_database" "{{ $db.Name }}" {
+  depends_on = [stackitprivatepreview_sqlserverflexalpha_user.{{ $db.Owner }}]
+  project_id    = "{{ $db.ProjectID }}"
+  instance_id   = stackitprivatepreview_sqlserverflexalpha_instance.{{ $tfName }}.instance_id
+  name          = "{{ $db.Name }}"
+  owner         = "{{ $db.Owner }}"
+{{ if $db.Collation }}
+  collation     = "{{ $db.Collation }}"
+{{ end }}
+{{ if $db.Compatibility }}
+  compatibility = "{{ $db.Compatibility }}"
+{{ end }}
+}
+{{ end }}
+{{ end }}

stackit/internal/services/sqlserverflexalpha/testdata/resource-max.tf

@@ -1,53 +0,0 @@
-# Copyright (c) STACKIT
-
-variable "project_id" {}
-variable "name" {}
-variable "acl1" {}
-variable "flavor_cpu" {}
-variable "flavor_ram" {}
-variable "storage_class" {}
-variable "storage_size" {}
-variable "options_retention_days" {}
-variable "backup_schedule" {}
-variable "username" {}
-variable "role" {}
-variable "server_version" {}
-variable "region" {}
-
-resource "stackit_sqlserverflex_instance" "instance" {
-  project_id = var.project_id
-  name       = var.name
-  acl        = [var.acl1]
-  flavor = {
-    cpu = var.flavor_cpu
-    ram = var.flavor_ram
-  }
-  storage = {
-    class = var.storage_class
-    size  = var.storage_size
-  }
-  version = var.server_version
-  options = {
-    retention_days = var.options_retention_days
-  }
-  backup_schedule = var.backup_schedule
-  region          = var.region
-}
-
-resource "stackit_sqlserverflex_user" "user" {
-  project_id  = stackit_sqlserverflex_instance.instance.project_id
-  instance_id = stackit_sqlserverflex_instance.instance.instance_id
-  username    = var.username
-  roles       = [var.role]
-}
-
-data "stackit_sqlserverflex_instance" "instance" {
-  project_id  = var.project_id
-  instance_id = stackit_sqlserverflex_instance.instance.instance_id
-}
-
-data "stackit_sqlserverflex_user" "user" {
-  project_id  = var.project_id
-  instance_id = stackit_sqlserverflex_instance.instance.instance_id
-  user_id     = stackit_sqlserverflex_user.user.user_id
-}

stackit/internal/services/sqlserverflexalpha/testdata/resource-min.tf

@@ -1,35 +0,0 @@
-# Copyright (c) STACKIT
-
-variable "project_id" {}
-variable "name" {}
-variable "flavor_cpu" {}
-variable "flavor_ram" {}
-variable "username" {}
-variable "role" {}
-
-resource "stackit_sqlserverflex_instance" "instance" {
-  project_id = var.project_id
-  name       = var.name
-  flavor = {
-    cpu = var.flavor_cpu
-    ram = var.flavor_ram
-  }
-}
-
-resource "stackit_sqlserverflex_user" "user" {
-  project_id  = stackit_sqlserverflex_instance.instance.project_id
-  instance_id = stackit_sqlserverflex_instance.instance.instance_id
-  username    = var.username
-  roles       = [var.role]
-}
-
-data "stackit_sqlserverflex_instance" "instance" {
-  project_id  = var.project_id
-  instance_id = stackit_sqlserverflex_instance.instance.instance_id
-}
-
-data "stackit_sqlserverflex_user" "user" {
-  project_id  = var.project_id
-  instance_id = stackit_sqlserverflex_instance.instance.instance_id
-  user_id     = stackit_sqlserverflex_user.user.user_id
-}

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

@@ -1,62 +1,50 @@
-// Copyright (c) STACKIT
-
 package sqlserverflexalpha
 
 import (
 	"context"
 	"fmt"
 	"net/http"
-	"strconv"
-
-	"github.com/hashicorp/terraform-plugin-framework-validators/int64validator"
-	"github.com/hashicorp/terraform-plugin-framework/attr"
-	"github.com/stackitcloud/terraform-provider-stackit/pkg/sqlserverflexalpha"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/conversion"
-	sqlserverflexUtils "github.com/stackitcloud/terraform-provider-stackit/stackit/internal/services/sqlserverflexalpha/utils"
 
 	"github.com/hashicorp/terraform-plugin-framework/datasource"
-	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
-	"github.com/hashicorp/terraform-plugin-log/tflog"
-	"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/datasource/schema"
 	"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/sqlserverflexalpha/utils"
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/utils"
+
+	sqlserverflexalphaPkg "github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3alpha1api"
+
+	sqlserverflexalphaGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/user/datasources_gen"
 )
 
-// Ensure the implementation satisfies the expected interfaces.
-var (
-	_ datasource.DataSource = &userDataSource{}
-)
+var _ datasource.DataSource = (*userDataSource)(nil)
 
-type DataSourceModel 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"`
-	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"`
-}
-
-// NewUserDataSource is a helper function to simplify the provider implementation.
 func NewUserDataSource() datasource.DataSource {
 	return &userDataSource{}
 }
 
-// userDataSource is the data source implementation.
+type dataSourceModel struct {
+	DefaultDatabase types.String `tfsdk:"default_database"`
+	Host            types.String `tfsdk:"host"`
+	Id              types.String `tfsdk:"id"`
+	InstanceId      types.String `tfsdk:"instance_id"`
+	Port            types.Int64  `tfsdk:"port"`
+	ProjectId       types.String `tfsdk:"project_id"`
+	Region          types.String `tfsdk:"region"`
+	Roles           types.List   `tfsdk:"roles"`
+	Status          types.String `tfsdk:"status"`
+	UserId          types.Int64  `tfsdk:"user_id"`
+	Username        types.String `tfsdk:"username"`
+}
+
 type userDataSource struct {
-	client       *sqlserverflexalpha.APIClient
+	client       *sqlserverflexalphaPkg.APIClient
 	providerData core.ProviderData
 }
 
-// Metadata returns the data source type name.
-func (r *userDataSource) Metadata(
+func (d *userDataSource) Metadata(
 	_ context.Context,
 	req datasource.MetadataRequest,
 	resp *datasource.MetadataResponse,
@@ -64,109 +52,32 @@ func (r *userDataSource) Metadata(
 	resp.TypeName = req.ProviderTypeName + "_sqlserverflexalpha_user"
 }
 
+func (d *userDataSource) Schema(ctx context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	resp.Schema = sqlserverflexalphaGen.UserDataSourceSchema(ctx)
+}
+
 // Configure adds the provider configured client to the data source.
-func (r *userDataSource) Configure(
+func (d *userDataSource) Configure(
 	ctx context.Context,
 	req datasource.ConfigureRequest,
 	resp *datasource.ConfigureResponse,
 ) {
 	var ok bool
-	r.providerData, ok = conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
+	d.providerData, ok = conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
 	if !ok {
 		return
 	}
 
-	apiClient := sqlserverflexUtils.ConfigureClient(ctx, &r.providerData, &resp.Diagnostics)
+	apiClient := sqlserverflexUtils.ConfigureClient(ctx, &d.providerData, &resp.Diagnostics)
 	if resp.Diagnostics.HasError() {
 		return
 	}
-	r.client = apiClient
-	tflog.Info(ctx, "SQLServer Flex user client configured")
+	d.client = apiClient
+	tflog.Info(ctx, "SQL SERVER Flex alpha database client configured")
 }
 
-// Schema defines the schema for the data source.
-func (r *userDataSource) Schema(_ context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
-	descriptions := map[string]string{
-		"main":             "SQLServer Flex user data source schema. Must have a `region` specified in the provider configuration.",
-		"id":               "Terraform's internal data source. 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.",
-		"password":         "Password of the user account.",
-		"region":           "The resource region. If not defined, the provider region is used.",
-		"status":           "Status of the user.",
-		"default_database": "Default database of the user.",
-	}
-
-	resp.Schema = schema.Schema{
-		Description: descriptions["main"],
-		Attributes: map[string]schema.Attribute{
-			"id": schema.StringAttribute{
-				Description: descriptions["id"],
-				Computed:    true,
-			},
-			"user_id": schema.Int64Attribute{
-				Description: descriptions["user_id"],
-				Required:    true,
-				Validators: []validator.Int64{
-					int64validator.AtLeast(1),
-				},
-			},
-			"instance_id": schema.StringAttribute{
-				Description: descriptions["instance_id"],
-				Required:    true,
-				Validators: []validator.String{
-					validate.UUID(),
-					validate.NoSeparator(),
-				},
-			},
-			"project_id": schema.StringAttribute{
-				Description: descriptions["project_id"],
-				Required:    true,
-				Validators: []validator.String{
-					validate.UUID(),
-					validate.NoSeparator(),
-				},
-			},
-			"username": schema.StringAttribute{
-				Description: descriptions["username"],
-				Computed:    true,
-			},
-			"roles": schema.SetAttribute{
-				Description: descriptions["roles"],
-				ElementType: types.StringType,
-				Computed:    true,
-			},
-			"host": schema.StringAttribute{
-				Computed: true,
-			},
-			"port": schema.Int64Attribute{
-				Computed: true,
-			},
-			"region": schema.StringAttribute{
-				// the region cannot be found automatically, so it has to be passed
-				Optional:    true,
-				Description: descriptions["region"],
-			},
-			"status": schema.StringAttribute{
-				Computed: true,
-			},
-			"default_database": schema.StringAttribute{
-				Computed: true,
-			},
-		},
-	}
-}
-
-// Read refreshes the Terraform state with the latest data.
-func (r *userDataSource) Read(
-	ctx context.Context,
-	req datasource.ReadRequest,
-	resp *datasource.ReadResponse,
-) { // nolint:gocritic // function signature required by Terraform
-	var model DataSourceModel
+func (d *userDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) {
+	var model dataSourceModel
 	diags := req.Config.Get(ctx, &model)
 	resp.Diagnostics.Append(diags...)
 	if resp.Diagnostics.HasError() {
@@ -178,13 +89,13 @@ func (r *userDataSource) Read(
 	projectId := model.ProjectId.ValueString()
 	instanceId := model.InstanceId.ValueString()
 	userId := model.UserId.ValueInt64()
-	region := r.providerData.GetRegionWithOverride(model.Region)
+	region := d.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()
+	recordSetResp, err := d.client.DefaultAPI.GetUserRequest(ctx, projectId, region, instanceId, userId).Execute()
 	if err != nil {
 		utils.LogError(
 			ctx,
@@ -225,50 +136,5 @@ func (r *userDataSource) Read(
 	if resp.Diagnostics.HasError() {
 		return
 	}
-	tflog.Info(ctx, "SQLServer Flex instance read")
-}
-
-func mapDataSourceFields(userResp *sqlserverflexalpha.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
-
-	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 {
-		model.Roles = 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 = rolesSet
-	}
-	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
+	tflog.Info(ctx, "SQLServer Flex Alpha instance read")
 }

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

@@ -1,149 +0,0 @@
-// Copyright (c) STACKIT
-
-package sqlserverflexalpha
-
-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"
-	"github.com/stackitcloud/terraform-provider-stackit/pkg/sqlserverflexalpha"
-)
-
-func TestMapDataSourceFields(t *testing.T) {
-	const testRegion = "region"
-	tests := []struct {
-		description string
-		input       *sqlserverflexalpha.GetUserResponse
-		region      string
-		expected    DataSourceModel
-		isValid     bool
-	}{
-		{
-			"default_values",
-			&sqlserverflexalpha.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.SetNull(types.StringType),
-				Host:            types.StringNull(),
-				Port:            types.Int64Null(),
-				Region:          types.StringValue(testRegion),
-				Status:          types.StringNull(),
-				DefaultDatabase: types.StringNull(),
-			},
-			true,
-		},
-		{
-			"simple_values",
-			&sqlserverflexalpha.GetUserResponse{
-
-				Roles: &[]sqlserverflexalpha.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.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",
-			&sqlserverflexalpha.GetUserResponse{
-				Id:       utils.Ptr(int64(1)),
-				Roles:    &[]sqlserverflexalpha.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.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",
-			&sqlserverflexalpha.GetUserResponse{},
-			testRegion,
-			DataSourceModel{},
-			false,
-		},
-		{
-			"no_resource_id",
-			&sqlserverflexalpha.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)
-					}
-				}
-			},
-		)
-	}
-}

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

@@ -0,0 +1,197 @@
+package sqlserverflexalpha
+
+import (
+	"fmt"
+	"slices"
+	"strconv"
+
+	"github.com/hashicorp/terraform-plugin-framework/attr"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
+	"github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3alpha1api"
+
+	"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 *v3alpha1api.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 != 0 {
+		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.StringValue(user.Username)
+
+	// Map roles
+	if user.Roles == nil {
+		model.Roles = types.List(types.SetNull(types.StringType))
+	} else {
+		resRoles := user.Roles
+		slices.Sort(resRoles)
+
+		var roles []attr.Value
+		for _, role := range resRoles {
+			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.StringValue(user.Host)
+	model.Port = types.Int64Value(int64(user.Port))
+	model.Region = types.StringValue(region)
+	model.Status = types.StringValue(user.Status)
+	model.DefaultDatabase = types.StringValue(user.DefaultDatabase)
+
+	return nil
+}
+
+// mapFields maps the API response to a resourceModel.
+func mapFields(userResp *v3alpha1api.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 != 0 {
+		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.StringValue(user.Username)
+
+	// Map roles
+	if user.Roles != nil {
+		resRoles := user.Roles
+		slices.Sort(resRoles)
+
+		var roles []attr.Value
+		for _, role := range resRoles {
+			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.StringValue(user.Host)
+	model.Port = types.Int64Value(int64(user.Port))
+	model.Region = types.StringValue(region)
+	return nil
+}
+
+// mapFieldsCreate maps the API response from creating a user to a resourceModel.
+func mapFieldsCreate(userResp *v3alpha1api.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 == 0 {
+		return fmt.Errorf("user id not present")
+	}
+	userID := user.Id
+	model.Id = types.Int64Value(userID)
+	model.UserId = types.Int64Value(userID)
+	model.Username = types.StringValue(user.Username)
+
+	if user.Password == "" {
+		return fmt.Errorf("user password not present")
+	}
+	model.Password = types.StringValue(user.Password)
+
+	if len(user.Roles) > 0 {
+		resRoles := user.Roles
+		slices.Sort(resRoles)
+
+		var roles []attr.Value
+		for _, role := range resRoles {
+			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.Password = types.StringValue(user.Password)
+	model.Uri = types.StringValue(user.Uri)
+
+	model.Host = types.StringValue(user.Host)
+	model.Port = types.Int64Value(int64(user.Port))
+	model.Region = types.StringValue(region)
+	model.Status = types.StringValue(user.Status)
+	model.DefaultDatabase = types.StringValue(user.DefaultDatabase)
+
+	return nil
+}
+
+// toCreatePayload converts a resourceModel to an API CreateUserRequestPayload.
+func toCreatePayload(
+	model *resourceModel,
+	roles []string,
+) (*v3alpha1api.CreateUserRequestPayload, error) {
+	if model == nil {
+		return nil, fmt.Errorf("nil model")
+	}
+
+	res := v3alpha1api.CreateUserRequestPayload{
+		Username:        model.Username.ValueString(),
+		DefaultDatabase: nil,
+		Roles:           roles,
+	}
+	if !model.DefaultDatabase.IsUnknown() && !model.DefaultDatabase.IsNull() {
+		res.DefaultDatabase = model.DefaultDatabase.ValueStringPointer()
+	}
+	return &res, nil
+}

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

@@ -0,0 +1,540 @@
+package sqlserverflexalpha
+
+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/services/sqlserverflex/v3alpha1api"
+)
+
+func TestMapDataSourceFields(t *testing.T) {
+	const testRegion = "region"
+	tests := []struct {
+		description string
+		input       *v3alpha1api.GetUserResponse
+		region      string
+		expected    dataSourceModel
+		isValid     bool
+	}{
+		{
+			"default_values",
+			&v3alpha1api.GetUserResponse{},
+			testRegion,
+			dataSourceModel{
+				Id:              types.StringValue("pid,region,iid,1"),
+				UserId:          types.Int64Value(1),
+				InstanceId:      types.StringValue("iid"),
+				ProjectId:       types.StringValue("pid"),
+				Username:        types.StringValue(""),
+				Roles:           types.List(types.SetNull(types.StringType)),
+				Host:            types.StringValue(""),
+				Port:            types.Int64Value(0),
+				Region:          types.StringValue(testRegion),
+				Status:          types.StringValue(""),
+				DefaultDatabase: types.StringValue(""),
+			},
+			true,
+		},
+		{
+			"simple_values",
+			&v3alpha1api.GetUserResponse{
+				Roles: []string{
+					"##STACKIT_SQLAgentUser##",
+					"##STACKIT_DatabaseManager##",
+					"##STACKIT_LoginManager##",
+					"##STACKIT_SQLAgentManager##",
+					"##STACKIT_ProcessManager##",
+					"##STACKIT_ServerManager##",
+				},
+				Username:        "username",
+				Host:            "host",
+				Port:            int32(1234),
+				Status:          "active",
+				DefaultDatabase: "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("##STACKIT_DatabaseManager##"),
+							types.StringValue("##STACKIT_LoginManager##"),
+							types.StringValue("##STACKIT_ProcessManager##"),
+							types.StringValue("##STACKIT_SQLAgentManager##"),
+							types.StringValue("##STACKIT_SQLAgentUser##"),
+							types.StringValue("##STACKIT_ServerManager##"),
+						},
+					),
+				),
+				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",
+			&v3alpha1api.GetUserResponse{
+				Id:       int64(1),
+				Roles:    []string{},
+				Username: "",
+				Host:     "",
+				Port:     int32(2123456789),
+			},
+			testRegion,
+			dataSourceModel{
+				Id:              types.StringValue("pid,region,iid,1"),
+				UserId:          types.Int64Value(1),
+				InstanceId:      types.StringValue("iid"),
+				ProjectId:       types.StringValue("pid"),
+				Username:        types.StringValue(""),
+				Roles:           types.List(types.SetValueMust(types.StringType, []attr.Value{})),
+				Host:            types.StringValue(""),
+				Port:            types.Int64Value(2123456789),
+				Region:          types.StringValue(testRegion),
+				DefaultDatabase: types.StringValue(""),
+				Status:          types.StringValue(""),
+			},
+			true,
+		},
+		{
+			"nil_response",
+			nil,
+			testRegion,
+			dataSourceModel{},
+			false,
+		},
+		{
+			"nil_response_2",
+			&v3alpha1api.GetUserResponse{},
+			testRegion,
+			dataSourceModel{},
+			false,
+		},
+		{
+			"no_resource_id",
+			&v3alpha1api.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(&tt.expected, state)
+					if diff != "" {
+						t.Fatalf("Data does not match: %s", diff)
+					}
+				}
+			},
+		)
+	}
+}
+
+func TestMapFieldsCreate(t *testing.T) {
+	const testRegion = "region"
+	tests := []struct {
+		description string
+		input       *v3alpha1api.CreateUserResponse
+		region      string
+		expected    resourceModel
+		isValid     bool
+	}{
+		{
+			"default_values",
+			&v3alpha1api.CreateUserResponse{
+				Id:       int64(1),
+				Password: "xy",
+			},
+			testRegion,
+			resourceModel{
+				Id:              types.Int64Value(1),
+				UserId:          types.Int64Value(1),
+				InstanceId:      types.StringValue("iid"),
+				ProjectId:       types.StringValue("pid"),
+				Username:        types.StringValue(""),
+				Roles:           types.List(types.SetNull(types.StringType)),
+				Password:        types.StringValue("xy"),
+				Host:            types.StringValue(""),
+				Port:            types.Int64Value(0),
+				Region:          types.StringValue(testRegion),
+				DefaultDatabase: types.StringValue(""),
+				Status:          types.StringValue(""),
+				Uri:             types.StringValue(""),
+			},
+			true,
+		},
+		{
+			"simple_values",
+			&v3alpha1api.CreateUserResponse{
+				Id: int64(2),
+				Roles: []string{
+					"role_2",
+					"role_1",
+					"",
+				},
+				Username:        "username",
+				Password:        "password",
+				Host:            "host",
+				Port:            int32(1234),
+				Status:          "status",
+				DefaultDatabase: "default_db",
+				Uri:             "myURI",
+			},
+			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(""),
+							types.StringValue("role_1"),
+							types.StringValue("role_2"),
+						},
+					),
+				),
+				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"),
+				Uri:             types.StringValue("myURI"),
+			},
+			true,
+		},
+		{
+			"null_fields_and_int_conversions",
+			&v3alpha1api.CreateUserResponse{
+				Id:       int64(3),
+				Roles:    []string{},
+				Username: "",
+				Password: "xy",
+				Host:     "",
+				Port:     int32(256789),
+			},
+			testRegion,
+			resourceModel{
+				Id:              types.Int64Value(3),
+				UserId:          types.Int64Value(3),
+				InstanceId:      types.StringValue("iid"),
+				ProjectId:       types.StringValue("pid"),
+				Username:        types.StringValue(""),
+				Roles:           types.ListNull(types.StringType),
+				Password:        types.StringValue("xy"),
+				Host:            types.StringValue(""),
+				Port:            types.Int64Value(256789),
+				Region:          types.StringValue(testRegion),
+				DefaultDatabase: types.StringValue(""),
+				Status:          types.StringValue(""),
+				Uri:             types.StringValue(""),
+			},
+			true,
+		},
+		{
+			"nil_response",
+			nil,
+			testRegion,
+			resourceModel{},
+			false,
+		},
+		{
+			"nil_response_2",
+			&v3alpha1api.CreateUserResponse{},
+			testRegion,
+			resourceModel{},
+			false,
+		},
+		{
+			"no_resource_id",
+			&v3alpha1api.CreateUserResponse{},
+			testRegion,
+			resourceModel{},
+			false,
+		},
+		{
+			"no_password",
+			&v3alpha1api.CreateUserResponse{
+				Id: 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(&tt.expected, state)
+					if diff != "" {
+						t.Fatalf("Data does not match: %s", diff)
+					}
+				}
+			},
+		)
+	}
+}
+
+func TestMapFields(t *testing.T) {
+	const testRegion = "region"
+	tests := []struct {
+		description string
+		input       *v3alpha1api.GetUserResponse
+		region      string
+		expected    resourceModel
+		isValid     bool
+	}{
+		{
+			"default_values",
+			&v3alpha1api.GetUserResponse{},
+			testRegion,
+			resourceModel{
+				Id:         types.Int64Value(1),
+				UserId:     types.Int64Value(1),
+				InstanceId: types.StringValue("iid"),
+				ProjectId:  types.StringValue("pid"),
+				Username:   types.StringValue(""),
+				Roles:      types.List(types.SetNull(types.StringType)),
+				Host:       types.StringValue(""),
+				Port:       types.Int64Value(0),
+				Region:     types.StringValue(testRegion),
+			},
+			true,
+		},
+		{
+			"simple_values",
+			&v3alpha1api.GetUserResponse{
+				Roles: []string{
+					"role_2",
+					"role_1",
+					"",
+				},
+				Username: ("username"),
+				Host:     ("host"),
+				Port:     (int32(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(""),
+							types.StringValue("role_1"),
+							types.StringValue("role_2"),
+						},
+					),
+				),
+				Host:   types.StringValue("host"),
+				Port:   types.Int64Value(1234),
+				Region: types.StringValue(testRegion),
+			},
+			true,
+		},
+		{
+			"null_fields_and_int_conversions",
+			&v3alpha1api.GetUserResponse{
+				Id:       int64(1),
+				Roles:    []string{},
+				Username: "",
+				Host:     "",
+				Port:     int32(2123456789),
+			},
+			testRegion,
+			resourceModel{
+				Id:         types.Int64Value(1),
+				UserId:     types.Int64Value(1),
+				InstanceId: types.StringValue("iid"),
+				ProjectId:  types.StringValue("pid"),
+				Username:   types.StringValue(""),
+				Roles:      types.List(types.SetValueMust(types.StringType, []attr.Value{})),
+				Host:       types.StringValue(""),
+				Port:       types.Int64Value(2123456789),
+				Region:     types.StringValue(testRegion),
+			},
+			true,
+		},
+		{
+			"nil_response",
+			nil,
+			testRegion,
+			resourceModel{},
+			false,
+		},
+		{
+			"nil_response_2",
+			&v3alpha1api.GetUserResponse{},
+			testRegion,
+			resourceModel{},
+			false,
+		},
+		{
+			"no_resource_id",
+			&v3alpha1api.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(&tt.expected, state)
+					if diff != "" {
+						t.Fatalf("Data does not match: %s", diff)
+					}
+				}
+			},
+		)
+	}
+}
+
+func TestToCreatePayload(t *testing.T) {
+	tests := []struct {
+		description string
+		input       *resourceModel
+		inputRoles  []string
+		expected    *v3alpha1api.CreateUserRequestPayload
+		isValid     bool
+	}{
+		{
+			"default_values",
+			&resourceModel{},
+			[]string{},
+			&v3alpha1api.CreateUserRequestPayload{
+				Roles:    []string{},
+				Username: "",
+			},
+			true,
+		},
+		{
+			"default_values",
+			&resourceModel{
+				Username: types.StringValue("username"),
+			},
+			[]string{
+				"role_1",
+				"role_2",
+			},
+			&v3alpha1api.CreateUserRequestPayload{
+				Roles: []string{
+					"role_1",
+					"role_2",
+				},
+				Username: "username",
+			},
+			true,
+		},
+		{
+			"null_fields_and_int_conversions",
+			&resourceModel{
+				Username: types.StringValue(""),
+			},
+			[]string{
+				"",
+			},
+			&v3alpha1api.CreateUserRequestPayload{
+				Roles: []string{
+					"",
+				},
+				Username: "",
+			},
+			true,
+		},
+		{
+			"nil_model",
+			nil,
+			[]string{},
+			nil,
+			false,
+		},
+		{
+			"nil_roles",
+			&resourceModel{
+				Username: types.StringValue("username"),
+			},
+			[]string{},
+			&v3alpha1api.CreateUserRequestPayload{
+				Roles:    []string{},
+				Username: "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(tt.expected, output)
+					if diff != "" {
+						t.Fatalf("Data does not match: %s", diff)
+					}
+				}
+			},
+		)
+	}
+}

stackit/internal/services/sqlserverflexalpha/user/planModifiers.yaml

@@ -0,0 +1,49 @@
+fields:
+  - name: 'id'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'instance_id'
+    validators:
+      - validate.NoSeparator
+      - validate.UUID
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'project_id'
+    validators:
+      - validate.NoSeparator
+      - validate.UUID
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'region'
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'user_id'
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'username'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'roles'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'password'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'uri'
+    modifiers:
+      - 'UseStateForUnknown'
+
+  - name: 'status'
+    modifiers:
+      - 'UseStateForUnknown'

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
-}

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

@@ -1,387 +0,0 @@
-// Copyright (c) STACKIT
-
-package sqlserverflexalpha
-
-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"
-	"github.com/stackitcloud/terraform-provider-stackit/pkg/sqlserverflexalpha"
-)
-
-func TestMapFieldsCreate(t *testing.T) {
-	const testRegion = "region"
-	tests := []struct {
-		description string
-		input       *sqlserverflexalpha.CreateUserResponse
-		region      string
-		expected    Model
-		isValid     bool
-	}{
-		{
-			"default_values",
-			&sqlserverflexalpha.CreateUserResponse{
-				Id:       utils.Ptr(int64(1)),
-				Password: utils.Ptr(""),
-			},
-			testRegion,
-			Model{
-				Id:         types.StringValue("pid,region,iid,1"),
-				UserId:     types.Int64Value(1),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Username:   types.StringNull(),
-				Roles:      types.SetNull(types.StringType),
-				Password:   types.StringValue(""),
-				Host:       types.StringNull(),
-				Port:       types.Int64Null(),
-				Region:     types.StringValue(testRegion),
-			},
-			true,
-		},
-		{
-			"simple_values",
-			&sqlserverflexalpha.CreateUserResponse{
-				Id: utils.Ptr(int64(2)),
-				Roles: &[]sqlserverflexalpha.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,
-			Model{
-				Id:         types.StringValue("pid,region,iid,2"),
-				UserId:     types.Int64Value(2),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Username:   types.StringValue("username"),
-				Roles: 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",
-			&sqlserverflexalpha.CreateUserResponse{
-				Id:       utils.Ptr(int64(3)),
-				Roles:    &[]sqlserverflexalpha.UserRole{},
-				Username: nil,
-				Password: utils.Ptr(""),
-				Host:     nil,
-				Port:     utils.Ptr(int64(2123456789)),
-			},
-			testRegion,
-			Model{
-				Id:              types.StringValue("pid,region,iid,3"),
-				UserId:          types.Int64Value(3),
-				InstanceId:      types.StringValue("iid"),
-				ProjectId:       types.StringValue("pid"),
-				Username:        types.StringNull(),
-				Roles:           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,
-			Model{},
-			false,
-		},
-		{
-			"nil_response_2",
-			&sqlserverflexalpha.CreateUserResponse{},
-			testRegion,
-			Model{},
-			false,
-		},
-		{
-			"no_resource_id",
-			&sqlserverflexalpha.CreateUserResponse{},
-			testRegion,
-			Model{},
-			false,
-		},
-		{
-			"no_password",
-			&sqlserverflexalpha.CreateUserResponse{
-				Id: utils.Ptr(int64(1)),
-			},
-			testRegion,
-			Model{},
-			false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(
-			tt.description, func(t *testing.T) {
-				state := &Model{
-					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       *sqlserverflexalpha.GetUserResponse
-		region      string
-		expected    Model
-		isValid     bool
-	}{
-		{
-			"default_values",
-			&sqlserverflexalpha.GetUserResponse{},
-			testRegion,
-			Model{
-				Id:         types.StringValue("pid,region,iid,1"),
-				UserId:     types.Int64Value(1),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Username:   types.StringNull(),
-				Roles:      types.SetNull(types.StringType),
-				Host:       types.StringNull(),
-				Port:       types.Int64Null(),
-				Region:     types.StringValue(testRegion),
-			},
-			true,
-		},
-		{
-			"simple_values",
-			&sqlserverflexalpha.GetUserResponse{
-				Roles: &[]sqlserverflexalpha.UserRole{
-					"role_1",
-					"role_2",
-					"",
-				},
-				Username: utils.Ptr("username"),
-				Host:     utils.Ptr("host"),
-				Port:     utils.Ptr(int64(1234)),
-			},
-			testRegion,
-			Model{
-				Id:         types.StringValue("pid,region,iid,2"),
-				UserId:     types.Int64Value(2),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Username:   types.StringValue("username"),
-				Roles: 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",
-			&sqlserverflexalpha.GetUserResponse{
-				Id:       utils.Ptr(int64(1)),
-				Roles:    &[]sqlserverflexalpha.UserRole{},
-				Username: nil,
-				Host:     nil,
-				Port:     utils.Ptr(int64(2123456789)),
-			},
-			testRegion,
-			Model{
-				Id:         types.StringValue("pid,region,iid,1"),
-				UserId:     types.Int64Value(1),
-				InstanceId: types.StringValue("iid"),
-				ProjectId:  types.StringValue("pid"),
-				Username:   types.StringNull(),
-				Roles:      types.SetValueMust(types.StringType, []attr.Value{}),
-				Host:       types.StringNull(),
-				Port:       types.Int64Value(2123456789),
-				Region:     types.StringValue(testRegion),
-			},
-			true,
-		},
-		{
-			"nil_response",
-			nil,
-			testRegion,
-			Model{},
-			false,
-		},
-		{
-			"nil_response_2",
-			&sqlserverflexalpha.GetUserResponse{},
-			testRegion,
-			Model{},
-			false,
-		},
-		{
-			"no_resource_id",
-			&sqlserverflexalpha.GetUserResponse{},
-			testRegion,
-			Model{},
-			false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(
-			tt.description, func(t *testing.T) {
-				state := &Model{
-					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       *Model
-		inputRoles  []sqlserverflexalpha.UserRole
-		expected    *sqlserverflexalpha.CreateUserRequestPayload
-		isValid     bool
-	}{
-		{
-			"default_values",
-			&Model{},
-			[]sqlserverflexalpha.UserRole{},
-			&sqlserverflexalpha.CreateUserRequestPayload{
-				Roles:    &[]sqlserverflexalpha.UserRole{},
-				Username: nil,
-			},
-			true,
-		},
-		{
-			"default_values",
-			&Model{
-				Username: types.StringValue("username"),
-			},
-			[]sqlserverflexalpha.UserRole{
-				"role_1",
-				"role_2",
-			},
-			&sqlserverflexalpha.CreateUserRequestPayload{
-				Roles: &[]sqlserverflexalpha.UserRole{
-					"role_1",
-					"role_2",
-				},
-				Username: utils.Ptr("username"),
-			},
-			true,
-		},
-		{
-			"null_fields_and_int_conversions",
-			&Model{
-				Username: types.StringNull(),
-			},
-			[]sqlserverflexalpha.UserRole{
-				"",
-			},
-			&sqlserverflexalpha.CreateUserRequestPayload{
-				Roles: &[]sqlserverflexalpha.UserRole{
-					"",
-				},
-				Username: nil,
-			},
-			true,
-		},
-		{
-			"nil_model",
-			nil,
-			[]sqlserverflexalpha.UserRole{},
-			nil,
-			false,
-		},
-		{
-			"nil_roles",
-			&Model{
-				Username: types.StringValue("username"),
-			},
-			[]sqlserverflexalpha.UserRole{},
-			&sqlserverflexalpha.CreateUserRequestPayload{
-				Roles:    &[]sqlserverflexalpha.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/sqlserverflexalpha/user/resources_gen/user_resource_gen.go

@@ -0,0 +1,111 @@
+// Code generated by terraform-plugin-framework-generator DO NOT EDIT.
+
+package sqlserverflexalpha
+
+import (
+	"context"
+	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
+	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
+	"github.com/hashicorp/terraform-plugin-framework/resource/schema"
+)
+
+func UserResourceSchema(ctx context.Context) schema.Schema {
+	return schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"default_database": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The default database for a user of the instance.",
+				MarkdownDescription: "The default database for a user of the instance.",
+			},
+			"host": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The host of the instance in which the user belongs to.",
+				MarkdownDescription: "The host of the instance in which the user belongs to.",
+			},
+			"id": schema.Int64Attribute{
+				Computed:            true,
+				Description:         "The ID of the user.",
+				MarkdownDescription: "The ID of the user.",
+			},
+			"instance_id": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The ID of the instance.",
+				MarkdownDescription: "The ID of the instance.",
+			},
+			"password": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The password for the user.",
+				MarkdownDescription: "The password for the user.",
+			},
+			"port": schema.Int64Attribute{
+				Computed:            true,
+				Description:         "The port of the instance in which the user belongs to.",
+				MarkdownDescription: "The port of the instance in which the user belongs to.",
+			},
+			"project_id": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The STACKIT project ID.",
+				MarkdownDescription: "The STACKIT project ID.",
+			},
+			"region": schema.StringAttribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The region which should be addressed",
+				MarkdownDescription: "The region which should be addressed",
+				Validators: []validator.String{
+					stringvalidator.OneOf(
+						"eu01",
+					),
+				},
+			},
+			"roles": schema.ListAttribute{
+				ElementType:         types.StringType,
+				Required:            true,
+				Description:         "A list containing the user roles for the instance. A list with the valid user roles can be retrieved using the List Roles endpoint.",
+				MarkdownDescription: "A list containing the user roles for the instance. A list with the valid user roles can be retrieved using the List Roles endpoint.",
+			},
+			"status": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The current status of the user.",
+				MarkdownDescription: "The current status of the user.",
+			},
+			"uri": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The connection string for the user to the instance.",
+				MarkdownDescription: "The connection string for the user to the instance.",
+			},
+			"user_id": schema.Int64Attribute{
+				Optional:            true,
+				Computed:            true,
+				Description:         "The ID of the user.",
+				MarkdownDescription: "The ID of the user.",
+			},
+			"username": schema.StringAttribute{
+				Required:            true,
+				Description:         "The name of the user.",
+				MarkdownDescription: "The name of the user.",
+			},
+		},
+	}
+}
+
+type UserModel struct {
+	DefaultDatabase types.String `tfsdk:"default_database"`
+	Host            types.String `tfsdk:"host"`
+	Id              types.Int64  `tfsdk:"id"`
+	InstanceId      types.String `tfsdk:"instance_id"`
+	Password        types.String `tfsdk:"password"`
+	Port            types.Int64  `tfsdk:"port"`
+	ProjectId       types.String `tfsdk:"project_id"`
+	Region          types.String `tfsdk:"region"`
+	Roles           types.List   `tfsdk:"roles"`
+	Status          types.String `tfsdk:"status"`
+	Uri             types.String `tfsdk:"uri"`
+	UserId          types.Int64  `tfsdk:"user_id"`
+	Username        types.String `tfsdk:"username"`
+}

stackit/internal/services/sqlserverflexalpha/utils/util.go

@@ -1,17 +1,16 @@
-// Copyright (c) STACKIT
-
 package utils
 
 import (
 	"context"
 	"fmt"
 
-	sqlserverflex "github.com/stackitcloud/terraform-provider-stackit/pkg/sqlserverflexalpha"
+	sqlserverflex "github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3alpha1api"
 
 	"github.com/hashicorp/terraform-plugin-framework/diag"
 	"github.com/stackitcloud/stackit-sdk-go/core/config"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/utils"
+
+	"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"
 )
 
 func ConfigureClient(

stackit/internal/services/sqlserverflexalpha/utils/util_test.go

@@ -1,5 +1,3 @@
-// Copyright (c) STACKIT
-
 package utils
 
 import (
@@ -11,10 +9,11 @@ import (
 	"github.com/hashicorp/terraform-plugin-framework/diag"
 	sdkClients "github.com/stackitcloud/stackit-sdk-go/core/clients"
 	"github.com/stackitcloud/stackit-sdk-go/core/config"
-	"github.com/stackitcloud/terraform-provider-stackit/pkg/sqlserverflexalpha"
 
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
-	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/utils"
+	sqlserverflex "github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3alpha1api"
+
+	"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"
 )
 
 const (
@@ -37,7 +36,7 @@ func TestConfigureClient(t *testing.T) {
 		name     string
 		args     args
 		wantErr  bool
-		expected *sqlserverflexalpha.APIClient
+		expected *sqlserverflex.APIClient
 	}{
 		{
 			name: "default endpoint",
@@ -46,8 +45,8 @@ func TestConfigureClient(t *testing.T) {
 					Version: testVersion,
 				},
 			},
-			expected: func() *sqlserverflexalpha.APIClient {
-				apiClient, err := sqlserverflexalpha.NewAPIClient(
+			expected: func() *sqlserverflex.APIClient {
+				apiClient, err := sqlserverflex.NewAPIClient(
 					config.WithRegion("eu01"),
 					utils.UserAgentConfigOption(testVersion),
 				)
@@ -66,8 +65,8 @@ func TestConfigureClient(t *testing.T) {
 					SQLServerFlexCustomEndpoint: testCustomEndpoint,
 				},
 			},
-			expected: func() *sqlserverflexalpha.APIClient {
-				apiClient, err := sqlserverflexalpha.NewAPIClient(
+			expected: func() *sqlserverflex.APIClient {
+				apiClient, err := sqlserverflex.NewAPIClient(
 					utils.UserAgentConfigOption(testVersion),
 					config.WithEndpoint(testCustomEndpoint),
 				)

stackit/internal/services/sqlserverflexalpha/versions/datasources_gen/version_data_source_gen.go

@@ -0,0 +1,569 @@
+// Code generated by terraform-plugin-framework-generator DO NOT EDIT.
+
+package sqlserverflexalpha
+
+import (
+	"context"
+	"fmt"
+	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
+	"github.com/hashicorp/terraform-plugin-framework/attr"
+	"github.com/hashicorp/terraform-plugin-framework/diag"
+	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
+	"github.com/hashicorp/terraform-plugin-go/tftypes"
+	"strings"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+)
+
+func VersionDataSourceSchema(ctx context.Context) schema.Schema {
+	return schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"project_id": schema.StringAttribute{
+				Required:            true,
+				Description:         "The STACKIT project ID.",
+				MarkdownDescription: "The STACKIT project ID.",
+			},
+			"region": schema.StringAttribute{
+				Required:            true,
+				Description:         "The region which should be addressed",
+				MarkdownDescription: "The region which should be addressed",
+				Validators: []validator.String{
+					stringvalidator.OneOf(
+						"eu01",
+					),
+				},
+			},
+			"versions": schema.ListNestedAttribute{
+				NestedObject: schema.NestedAttributeObject{
+					Attributes: map[string]schema.Attribute{
+						"beta": schema.BoolAttribute{
+							Computed:            true,
+							Description:         "Flag if the version is a beta version. If set the version may contain bugs and is not fully tested.",
+							MarkdownDescription: "Flag if the version is a beta version. If set the version may contain bugs and is not fully tested.",
+						},
+						"deprecated": schema.StringAttribute{
+							Computed:            true,
+							Description:         "Timestamp in RFC3339 format which says when the version will no longer be supported by STACKIT.",
+							MarkdownDescription: "Timestamp in RFC3339 format which says when the version will no longer be supported by STACKIT.",
+						},
+						"recommend": schema.BoolAttribute{
+							Computed:            true,
+							Description:         "Flag if the version is recommend by the STACKIT Team.",
+							MarkdownDescription: "Flag if the version is recommend by the STACKIT Team.",
+						},
+						"version": schema.StringAttribute{
+							Computed:            true,
+							Description:         "The sqlserver version used for the instance.",
+							MarkdownDescription: "The sqlserver version used for the instance.",
+						},
+					},
+					CustomType: VersionsType{
+						ObjectType: types.ObjectType{
+							AttrTypes: VersionsValue{}.AttributeTypes(ctx),
+						},
+					},
+				},
+				Computed:            true,
+				Description:         "A list containing available sqlserver versions.",
+				MarkdownDescription: "A list containing available sqlserver versions.",
+			},
+		},
+	}
+}
+
+type VersionModel struct {
+	ProjectId types.String `tfsdk:"project_id"`
+	Region    types.String `tfsdk:"region"`
+	Versions  types.List   `tfsdk:"versions"`
+}
+
+var _ basetypes.ObjectTypable = VersionsType{}
+
+type VersionsType struct {
+	basetypes.ObjectType
+}
+
+func (t VersionsType) Equal(o attr.Type) bool {
+	other, ok := o.(VersionsType)
+
+	if !ok {
+		return false
+	}
+
+	return t.ObjectType.Equal(other.ObjectType)
+}
+
+func (t VersionsType) String() string {
+	return "VersionsType"
+}
+
+func (t VersionsType) ValueFromObject(ctx context.Context, in basetypes.ObjectValue) (basetypes.ObjectValuable, diag.Diagnostics) {
+	var diags diag.Diagnostics
+
+	attributes := in.Attributes()
+
+	betaAttribute, ok := attributes["beta"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`beta is missing from object`)
+
+		return nil, diags
+	}
+
+	betaVal, ok := betaAttribute.(basetypes.BoolValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`beta expected to be basetypes.BoolValue, was: %T`, betaAttribute))
+	}
+
+	deprecatedAttribute, ok := attributes["deprecated"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`deprecated is missing from object`)
+
+		return nil, diags
+	}
+
+	deprecatedVal, ok := deprecatedAttribute.(basetypes.StringValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`deprecated expected to be basetypes.StringValue, was: %T`, deprecatedAttribute))
+	}
+
+	recommendAttribute, ok := attributes["recommend"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`recommend is missing from object`)
+
+		return nil, diags
+	}
+
+	recommendVal, ok := recommendAttribute.(basetypes.BoolValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`recommend expected to be basetypes.BoolValue, was: %T`, recommendAttribute))
+	}
+
+	versionAttribute, ok := attributes["version"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`version is missing from object`)
+
+		return nil, diags
+	}
+
+	versionVal, ok := versionAttribute.(basetypes.StringValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`version expected to be basetypes.StringValue, was: %T`, versionAttribute))
+	}
+
+	if diags.HasError() {
+		return nil, diags
+	}
+
+	return VersionsValue{
+		Beta:       betaVal,
+		Deprecated: deprecatedVal,
+		Recommend:  recommendVal,
+		Version:    versionVal,
+		state:      attr.ValueStateKnown,
+	}, diags
+}
+
+func NewVersionsValueNull() VersionsValue {
+	return VersionsValue{
+		state: attr.ValueStateNull,
+	}
+}
+
+func NewVersionsValueUnknown() VersionsValue {
+	return VersionsValue{
+		state: attr.ValueStateUnknown,
+	}
+}
+
+func NewVersionsValue(attributeTypes map[string]attr.Type, attributes map[string]attr.Value) (VersionsValue, diag.Diagnostics) {
+	var diags diag.Diagnostics
+
+	// Reference: https://github.com/hashicorp/terraform-plugin-framework/issues/521
+	ctx := context.Background()
+
+	for name, attributeType := range attributeTypes {
+		attribute, ok := attributes[name]
+
+		if !ok {
+			diags.AddError(
+				"Missing VersionsValue Attribute Value",
+				"While creating a VersionsValue value, a missing attribute value was detected. "+
+					"A VersionsValue must contain values for all attributes, even if null or unknown. "+
+					"This is always an issue with the provider and should be reported to the provider developers.\n\n"+
+					fmt.Sprintf("VersionsValue Attribute Name (%s) Expected Type: %s", name, attributeType.String()),
+			)
+
+			continue
+		}
+
+		if !attributeType.Equal(attribute.Type(ctx)) {
+			diags.AddError(
+				"Invalid VersionsValue Attribute Type",
+				"While creating a VersionsValue value, an invalid attribute value was detected. "+
+					"A VersionsValue must use a matching attribute type for the value. "+
+					"This is always an issue with the provider and should be reported to the provider developers.\n\n"+
+					fmt.Sprintf("VersionsValue Attribute Name (%s) Expected Type: %s\n", name, attributeType.String())+
+					fmt.Sprintf("VersionsValue Attribute Name (%s) Given Type: %s", name, attribute.Type(ctx)),
+			)
+		}
+	}
+
+	for name := range attributes {
+		_, ok := attributeTypes[name]
+
+		if !ok {
+			diags.AddError(
+				"Extra VersionsValue Attribute Value",
+				"While creating a VersionsValue value, an extra attribute value was detected. "+
+					"A VersionsValue must not contain values beyond the expected attribute types. "+
+					"This is always an issue with the provider and should be reported to the provider developers.\n\n"+
+					fmt.Sprintf("Extra VersionsValue Attribute Name: %s", name),
+			)
+		}
+	}
+
+	if diags.HasError() {
+		return NewVersionsValueUnknown(), diags
+	}
+
+	betaAttribute, ok := attributes["beta"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`beta is missing from object`)
+
+		return NewVersionsValueUnknown(), diags
+	}
+
+	betaVal, ok := betaAttribute.(basetypes.BoolValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`beta expected to be basetypes.BoolValue, was: %T`, betaAttribute))
+	}
+
+	deprecatedAttribute, ok := attributes["deprecated"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`deprecated is missing from object`)
+
+		return NewVersionsValueUnknown(), diags
+	}
+
+	deprecatedVal, ok := deprecatedAttribute.(basetypes.StringValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`deprecated expected to be basetypes.StringValue, was: %T`, deprecatedAttribute))
+	}
+
+	recommendAttribute, ok := attributes["recommend"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`recommend is missing from object`)
+
+		return NewVersionsValueUnknown(), diags
+	}
+
+	recommendVal, ok := recommendAttribute.(basetypes.BoolValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`recommend expected to be basetypes.BoolValue, was: %T`, recommendAttribute))
+	}
+
+	versionAttribute, ok := attributes["version"]
+
+	if !ok {
+		diags.AddError(
+			"Attribute Missing",
+			`version is missing from object`)
+
+		return NewVersionsValueUnknown(), diags
+	}
+
+	versionVal, ok := versionAttribute.(basetypes.StringValue)
+
+	if !ok {
+		diags.AddError(
+			"Attribute Wrong Type",
+			fmt.Sprintf(`version expected to be basetypes.StringValue, was: %T`, versionAttribute))
+	}
+
+	if diags.HasError() {
+		return NewVersionsValueUnknown(), diags
+	}
+
+	return VersionsValue{
+		Beta:       betaVal,
+		Deprecated: deprecatedVal,
+		Recommend:  recommendVal,
+		Version:    versionVal,
+		state:      attr.ValueStateKnown,
+	}, diags
+}
+
+func NewVersionsValueMust(attributeTypes map[string]attr.Type, attributes map[string]attr.Value) VersionsValue {
+	object, diags := NewVersionsValue(attributeTypes, attributes)
+
+	if diags.HasError() {
+		// This could potentially be added to the diag package.
+		diagsStrings := make([]string, 0, len(diags))
+
+		for _, diagnostic := range diags {
+			diagsStrings = append(diagsStrings, fmt.Sprintf(
+				"%s | %s | %s",
+				diagnostic.Severity(),
+				diagnostic.Summary(),
+				diagnostic.Detail()))
+		}
+
+		panic("NewVersionsValueMust received error(s): " + strings.Join(diagsStrings, "\n"))
+	}
+
+	return object
+}
+
+func (t VersionsType) ValueFromTerraform(ctx context.Context, in tftypes.Value) (attr.Value, error) {
+	if in.Type() == nil {
+		return NewVersionsValueNull(), nil
+	}
+
+	if !in.Type().Equal(t.TerraformType(ctx)) {
+		return nil, fmt.Errorf("expected %s, got %s", t.TerraformType(ctx), in.Type())
+	}
+
+	if !in.IsKnown() {
+		return NewVersionsValueUnknown(), nil
+	}
+
+	if in.IsNull() {
+		return NewVersionsValueNull(), nil
+	}
+
+	attributes := map[string]attr.Value{}
+
+	val := map[string]tftypes.Value{}
+
+	err := in.As(&val)
+
+	if err != nil {
+		return nil, err
+	}
+
+	for k, v := range val {
+		a, err := t.AttrTypes[k].ValueFromTerraform(ctx, v)
+
+		if err != nil {
+			return nil, err
+		}
+
+		attributes[k] = a
+	}
+
+	return NewVersionsValueMust(VersionsValue{}.AttributeTypes(ctx), attributes), nil
+}
+
+func (t VersionsType) ValueType(ctx context.Context) attr.Value {
+	return VersionsValue{}
+}
+
+var _ basetypes.ObjectValuable = VersionsValue{}
+
+type VersionsValue struct {
+	Beta       basetypes.BoolValue   `tfsdk:"beta"`
+	Deprecated basetypes.StringValue `tfsdk:"deprecated"`
+	Recommend  basetypes.BoolValue   `tfsdk:"recommend"`
+	Version    basetypes.StringValue `tfsdk:"version"`
+	state      attr.ValueState
+}
+
+func (v VersionsValue) ToTerraformValue(ctx context.Context) (tftypes.Value, error) {
+	attrTypes := make(map[string]tftypes.Type, 4)
+
+	var val tftypes.Value
+	var err error
+
+	attrTypes["beta"] = basetypes.BoolType{}.TerraformType(ctx)
+	attrTypes["deprecated"] = basetypes.StringType{}.TerraformType(ctx)
+	attrTypes["recommend"] = basetypes.BoolType{}.TerraformType(ctx)
+	attrTypes["version"] = basetypes.StringType{}.TerraformType(ctx)
+
+	objectType := tftypes.Object{AttributeTypes: attrTypes}
+
+	switch v.state {
+	case attr.ValueStateKnown:
+		vals := make(map[string]tftypes.Value, 4)
+
+		val, err = v.Beta.ToTerraformValue(ctx)
+
+		if err != nil {
+			return tftypes.NewValue(objectType, tftypes.UnknownValue), err
+		}
+
+		vals["beta"] = val
+
+		val, err = v.Deprecated.ToTerraformValue(ctx)
+
+		if err != nil {
+			return tftypes.NewValue(objectType, tftypes.UnknownValue), err
+		}
+
+		vals["deprecated"] = val
+
+		val, err = v.Recommend.ToTerraformValue(ctx)
+
+		if err != nil {
+			return tftypes.NewValue(objectType, tftypes.UnknownValue), err
+		}
+
+		vals["recommend"] = val
+
+		val, err = v.Version.ToTerraformValue(ctx)
+
+		if err != nil {
+			return tftypes.NewValue(objectType, tftypes.UnknownValue), err
+		}
+
+		vals["version"] = val
+
+		if err := tftypes.ValidateValue(objectType, vals); err != nil {
+			return tftypes.NewValue(objectType, tftypes.UnknownValue), err
+		}
+
+		return tftypes.NewValue(objectType, vals), nil
+	case attr.ValueStateNull:
+		return tftypes.NewValue(objectType, nil), nil
+	case attr.ValueStateUnknown:
+		return tftypes.NewValue(objectType, tftypes.UnknownValue), nil
+	default:
+		panic(fmt.Sprintf("unhandled Object state in ToTerraformValue: %s", v.state))
+	}
+}
+
+func (v VersionsValue) IsNull() bool {
+	return v.state == attr.ValueStateNull
+}
+
+func (v VersionsValue) IsUnknown() bool {
+	return v.state == attr.ValueStateUnknown
+}
+
+func (v VersionsValue) String() string {
+	return "VersionsValue"
+}
+
+func (v VersionsValue) ToObjectValue(ctx context.Context) (basetypes.ObjectValue, diag.Diagnostics) {
+	var diags diag.Diagnostics
+
+	attributeTypes := map[string]attr.Type{
+		"beta":       basetypes.BoolType{},
+		"deprecated": basetypes.StringType{},
+		"recommend":  basetypes.BoolType{},
+		"version":    basetypes.StringType{},
+	}
+
+	if v.IsNull() {
+		return types.ObjectNull(attributeTypes), diags
+	}
+
+	if v.IsUnknown() {
+		return types.ObjectUnknown(attributeTypes), diags
+	}
+
+	objVal, diags := types.ObjectValue(
+		attributeTypes,
+		map[string]attr.Value{
+			"beta":       v.Beta,
+			"deprecated": v.Deprecated,
+			"recommend":  v.Recommend,
+			"version":    v.Version,
+		})
+
+	return objVal, diags
+}
+
+func (v VersionsValue) Equal(o attr.Value) bool {
+	other, ok := o.(VersionsValue)
+
+	if !ok {
+		return false
+	}
+
+	if v.state != other.state {
+		return false
+	}
+
+	if v.state != attr.ValueStateKnown {
+		return true
+	}
+
+	if !v.Beta.Equal(other.Beta) {
+		return false
+	}
+
+	if !v.Deprecated.Equal(other.Deprecated) {
+		return false
+	}
+
+	if !v.Recommend.Equal(other.Recommend) {
+		return false
+	}
+
+	if !v.Version.Equal(other.Version) {
+		return false
+	}
+
+	return true
+}
+
+func (v VersionsValue) Type(ctx context.Context) attr.Type {
+	return VersionsType{
+		basetypes.ObjectType{
+			AttrTypes: v.AttributeTypes(ctx),
+		},
+	}
+}
+
+func (v VersionsValue) AttributeTypes(ctx context.Context) map[string]attr.Type {
+	return map[string]attr.Type{
+		"beta":       basetypes.BoolType{},
+		"deprecated": basetypes.StringType{},
+		"recommend":  basetypes.BoolType{},
+		"version":    basetypes.StringType{},
+	}
+}

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

@@ -0,0 +1,175 @@
+package sqlserverflexbeta
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource"
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+	"github.com/hashicorp/terraform-plugin-framework/diag"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/hashicorp/terraform-plugin-log/tflog"
+	"github.com/stackitcloud/stackit-sdk-go/core/config"
+
+	"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"
+
+	sqlserverflexbetaPkg "github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3beta1api"
+
+	sqlserverflexbetaGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/database/datasources_gen"
+)
+
+var _ datasource.DataSource = (*databaseDataSource)(nil)
+
+const errorPrefix = "[Sqlserverflexbeta - Database]"
+
+func NewDatabaseDataSource() datasource.DataSource {
+	return &databaseDataSource{}
+}
+
+type dataSourceModel struct {
+	sqlserverflexbetaGen.DatabaseModel
+	TerraformId types.String `tfsdk:"id"`
+}
+
+type databaseDataSource struct {
+	client       *sqlserverflexbetaPkg.APIClient
+	providerData core.ProviderData
+}
+
+func (d *databaseDataSource) Metadata(
+	_ context.Context,
+	req datasource.MetadataRequest,
+	resp *datasource.MetadataResponse,
+) {
+	resp.TypeName = req.ProviderTypeName + "_sqlserverflexbeta_database"
+}
+
+func (d *databaseDataSource) Schema(ctx context.Context, _ datasource.SchemaRequest, resp *datasource.SchemaResponse) {
+	resp.Schema = sqlserverflexbetaGen.DatabaseDataSourceSchema(ctx)
+	resp.Schema.Attributes["id"] = schema.StringAttribute{
+		Computed:            true,
+		Description:         "The terraform internal identifier.",
+		MarkdownDescription: "The terraform internal identifier.",
+	}
+}
+
+// Configure adds the provider configured client to the data source.
+func (d *databaseDataSource) Configure(
+	ctx context.Context,
+	req datasource.ConfigureRequest,
+	resp *datasource.ConfigureResponse,
+) {
+	var ok bool
+	d.providerData, ok = conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
+	if !ok {
+		return
+	}
+
+	apiClientConfigOptions := []config.ConfigurationOption{
+		config.WithCustomAuth(d.providerData.RoundTripper),
+		utils.UserAgentConfigOption(d.providerData.Version),
+	}
+	if d.providerData.SQLServerFlexCustomEndpoint != "" {
+		apiClientConfigOptions = append(
+			apiClientConfigOptions,
+			config.WithEndpoint(d.providerData.SQLServerFlexCustomEndpoint),
+		)
+	} else {
+		apiClientConfigOptions = append(
+			apiClientConfigOptions,
+			config.WithRegion(d.providerData.GetRegion()),
+		)
+	}
+	apiClient, err := sqlserverflexbetaPkg.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,
+			),
+		)
+		return
+	}
+	d.client = apiClient
+	tflog.Info(ctx, fmt.Sprintf("%s client configured", errorPrefix))
+}
+
+func (d *databaseDataSource) 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)...)
+
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	ctx = core.InitProviderContext(ctx)
+
+	// Extract identifiers from the plan
+	projectId := data.ProjectId.ValueString()
+	region := d.providerData.GetRegionWithOverride(data.Region)
+	instanceId := data.InstanceId.ValueString()
+
+	ctx = tflog.SetField(ctx, "project_id", projectId)
+	ctx = tflog.SetField(ctx, "region", region)
+	ctx = tflog.SetField(ctx, "instance_id", instanceId)
+
+	databaseName := data.DatabaseName.ValueString()
+
+	databaseResp, err := d.client.DefaultAPI.GetDatabaseRequest(ctx, projectId, region, instanceId, databaseName).Execute()
+	if err != nil {
+		handleReadError(ctx, &resp.Diagnostics, err, projectId, instanceId)
+		resp.State.RemoveResource(ctx)
+		return
+	}
+
+	ctx = core.LogResponse(ctx)
+	// Map response body to schema and populate Computed attribute values
+	err = mapFields(databaseResp, &data, region)
+	if err != nil {
+		core.LogAndAddError(
+			ctx,
+			&resp.Diagnostics,
+			"Error reading database",
+			fmt.Sprintf("Processing API payload: %v", err),
+		)
+		return
+	}
+
+	// Save data into Terraform state
+	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
+
+	tflog.Info(ctx, "SQL Server Flex beta database read")
+}
+
+// handleReadError centralizes API error handling for the Read operation.
+func handleReadError(ctx context.Context, diags *diag.Diagnostics, err error, projectId, instanceId string) {
+	utils.LogError(
+		ctx,
+		diags,
+		err,
+		"Reading database",
+		fmt.Sprintf(
+			"Could not retrieve database for instance %q in project %q.",
+			instanceId,
+			projectId,
+		),
+		map[int]string{
+			http.StatusBadRequest: fmt.Sprintf(
+				"Invalid request parameters for project %q and instance %q.",
+				projectId,
+				instanceId,
+			),
+			http.StatusNotFound: fmt.Sprintf(
+				"Database, instance %q, or project %q not found.",
+				instanceId,
+				projectId,
+			),
+			http.StatusForbidden: fmt.Sprintf("Forbidden access to project %q.", projectId),
+		},
+	)
+}

stackit/internal/services/sqlserverflexbeta/database/datasources_gen/database_data_source_gen.go

@@ -0,0 +1,81 @@
+// Code generated by terraform-plugin-framework-generator DO NOT EDIT.
+
+package sqlserverflexbeta
+
+import (
+	"context"
+	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
+	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+
+	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+)
+
+func DatabaseDataSourceSchema(ctx context.Context) schema.Schema {
+	return schema.Schema{
+		Attributes: map[string]schema.Attribute{
+			"collation_name": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The collation of the database. This database collation should match the *collation_name* of one of the collations given by the **Get database collation list** endpoint.",
+				MarkdownDescription: "The collation of the database. This database collation should match the *collation_name* of one of the collations given by the **Get database collation list** endpoint.",
+			},
+			"compatibility_level": schema.Int64Attribute{
+				Computed:            true,
+				Description:         "CompatibilityLevel of the Database.",
+				MarkdownDescription: "CompatibilityLevel of the Database.",
+			},
+			"database_name": schema.StringAttribute{
+				Required:            true,
+				Description:         "The name of the database.",
+				MarkdownDescription: "The name of the database.",
+			},
+			"tf_original_api_id": schema.Int64Attribute{
+				Computed:            true,
+				Description:         "The id of the database.",
+				MarkdownDescription: "The id of the database.",
+			},
+			"instance_id": schema.StringAttribute{
+				Required:            true,
+				Description:         "The ID of the instance.",
+				MarkdownDescription: "The ID of the instance.",
+			},
+			"name": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The name of the database.",
+				MarkdownDescription: "The name of the database.",
+			},
+			"owner": schema.StringAttribute{
+				Computed:            true,
+				Description:         "The owner of the database.",
+				MarkdownDescription: "The owner of the database.",
+			},
+			"project_id": schema.StringAttribute{
+				Required:            true,
+				Description:         "The STACKIT project ID.",
+				MarkdownDescription: "The STACKIT project ID.",
+			},
+			"region": schema.StringAttribute{
+				Required:            true,
+				Description:         "The region which should be addressed",
+				MarkdownDescription: "The region which should be addressed",
+				Validators: []validator.String{
+					stringvalidator.OneOf(
+						"eu01",
+					),
+				},
+			},
+		},
+	}
+}
+
+type DatabaseModel struct {
+	CollationName      types.String `tfsdk:"collation_name"`
+	CompatibilityLevel types.Int64  `tfsdk:"compatibility_level"`
+	DatabaseName       types.String `tfsdk:"database_name"`
+	Id                 types.Int64  `tfsdk:"tf_original_api_id"`
+	InstanceId         types.String `tfsdk:"instance_id"`
+	Name               types.String `tfsdk:"name"`
+	Owner              types.String `tfsdk:"owner"`
+	ProjectId          types.String `tfsdk:"project_id"`
+	Region             types.String `tfsdk:"region"`
+}

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

@@ -0,0 +1,105 @@
+package sqlserverflexbeta
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	utils2 "github.com/stackitcloud/stackit-sdk-go/core/utils"
+
+	sqlserverflexbeta "github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3beta1api"
+
+	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/utils"
+)
+
+// mapFields maps fields from a ListDatabase API response to a resourceModel for the data source.
+func mapFields(source *sqlserverflexbeta.GetDatabaseResponse, model *dataSourceModel, region string) error {
+	if source == nil {
+		return fmt.Errorf("response is nil")
+	}
+	if source.Id == 0 {
+		return fmt.Errorf("id not present")
+	}
+	if model == nil {
+		return fmt.Errorf("model given is nil")
+	}
+
+	var databaseId int64
+	if model.Id.ValueInt64() != 0 {
+		databaseId = model.Id.ValueInt64()
+	} else if source.Id != 0 {
+		databaseId = source.Id
+	} else {
+		return fmt.Errorf("database id not present")
+	}
+
+	model.Id = types.Int64Value(databaseId)
+	model.DatabaseName = types.StringValue(source.GetName())
+	model.Name = types.StringValue(source.GetName())
+	model.Owner = types.StringValue(source.GetOwner())
+	model.Region = types.StringValue(region)
+	model.ProjectId = types.StringValue(model.ProjectId.ValueString())
+	model.InstanceId = types.StringValue(model.InstanceId.ValueString())
+	model.CompatibilityLevel = types.Int64Value(int64(source.GetCompatibilityLevel()))
+	model.CollationName = types.StringValue(source.GetCollationName())
+
+	model.TerraformId = utils.BuildInternalTerraformId(
+		model.ProjectId.ValueString(),
+		region,
+		model.InstanceId.ValueString(),
+		model.DatabaseName.ValueString(),
+	)
+
+	return nil
+}
+
+// mapResourceFields maps fields from a ListDatabase API response to a resourceModel for the resource.
+func mapResourceFields(source *sqlserverflexbeta.GetDatabaseResponse, model *resourceModel, region string) error {
+	if source == nil {
+		return fmt.Errorf("response is nil")
+	}
+	if source.Id == 0 {
+		return fmt.Errorf("id not present")
+	}
+	if model == nil {
+		return fmt.Errorf("model input is nil")
+	}
+
+	var databaseId int64
+	if model.Id.ValueInt64() != 0 {
+		databaseId = model.Id.ValueInt64()
+	} else if source.Id != 0 {
+		databaseId = source.Id
+	} else {
+		return fmt.Errorf("database id not present")
+	}
+
+	model.Id = types.Int64Value(databaseId)
+	model.DatabaseName = types.StringValue(source.GetName())
+	model.Name = types.StringValue(source.GetName())
+	model.Owner = types.StringValue(source.GetOwner())
+	model.Region = types.StringValue(region)
+	model.ProjectId = types.StringValue(model.ProjectId.ValueString())
+	model.InstanceId = types.StringValue(model.InstanceId.ValueString())
+
+	model.Compatibility = types.Int64Value(int64(source.GetCompatibilityLevel()))
+	model.CompatibilityLevel = types.Int64Value(int64(source.GetCompatibilityLevel()))
+
+	model.Collation = types.StringValue(source.GetCollationName()) // it does not come back from api
+	model.CollationName = types.StringValue(source.GetCollationName())
+
+	return nil
+}
+
+// toCreatePayload converts the resource model to an API create payload.
+func toCreatePayload(model *resourceModel) (*sqlserverflexbeta.CreateDatabaseRequestPayload, error) {
+	if model == nil {
+		return nil, fmt.Errorf("nil model")
+	}
+
+	return &sqlserverflexbeta.CreateDatabaseRequestPayload{
+		Name:          model.Name.ValueString(),
+		Owner:         model.Owner.ValueString(),
+		Collation:     model.Collation.ValueStringPointer(),
+		Compatibility: utils2.Ptr(int32(model.Compatibility.ValueInt64())), //nolint:gosec // TODO
+	}, nil
+}

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

@@ -0,0 +1,233 @@
+package sqlserverflexbeta
+
+import (
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/stackitcloud/stackit-sdk-go/core/utils"
+	"github.com/stackitcloud/stackit-sdk-go/services/sqlserverflex/v3beta1api"
+
+	datasource "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/database/datasources_gen"
+)
+
+func TestMapFields(t *testing.T) {
+	type given struct {
+		source *v3beta1api.GetDatabaseResponse
+		model  *dataSourceModel
+		region string
+	}
+	type expected struct {
+		model *dataSourceModel
+		err   bool
+	}
+
+	testcases := []struct {
+		name     string
+		given    given
+		expected expected
+	}{
+		{
+			name: "should map fields correctly",
+			given: given{
+				source: &v3beta1api.GetDatabaseResponse{
+					Id:                 int64(1),
+					Name:               "my-db",
+					CollationName:      "collation",
+					CompatibilityLevel: int32(150),
+					Owner:              "my-owner",
+				},
+				model: &dataSourceModel{
+					DatabaseModel: datasource.DatabaseModel{
+						ProjectId:  types.StringValue("my-project"),
+						InstanceId: types.StringValue("my-instance"),
+					},
+				},
+				region: "eu01",
+			},
+			expected: expected{
+				model: &dataSourceModel{
+					DatabaseModel: datasource.DatabaseModel{
+						Id:                 types.Int64Value(1),
+						Name:               types.StringValue("my-db"),
+						DatabaseName:       types.StringValue("my-db"),
+						Owner:              types.StringValue("my-owner"),
+						Region:             types.StringValue("eu01"),
+						InstanceId:         types.StringValue("my-instance"),
+						ProjectId:          types.StringValue("my-project"),
+						CompatibilityLevel: types.Int64Value(150),
+						CollationName:      types.StringValue("collation"),
+					},
+					TerraformId: types.StringValue("my-project,eu01,my-instance,my-db"),
+				},
+			},
+		},
+		{
+			name: "should fail on nil source",
+			given: given{
+				source: nil,
+				model:  &dataSourceModel{},
+			},
+			expected: expected{err: true},
+		},
+		{
+			name: "should fail on nil source ID",
+			given: given{
+				source: &v3beta1api.GetDatabaseResponse{Id: 0},
+				model:  &dataSourceModel{},
+			},
+			expected: expected{err: true},
+		},
+		{
+			name: "should fail on nil model",
+			given: given{
+				source: &v3beta1api.GetDatabaseResponse{Id: int64(1)},
+				model:  nil,
+			},
+			expected: expected{err: true},
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(
+			tc.name, func(t *testing.T) {
+				err := mapFields(tc.given.source, tc.given.model, tc.given.region)
+				if (err != nil) != tc.expected.err {
+					t.Fatalf("expected error: %v, got: %v", tc.expected.err, err)
+				}
+				if err == nil {
+					if diff := cmp.Diff(tc.expected.model, tc.given.model); diff != "" {
+						t.Errorf("model mismatch (-want +got):\n%s", diff)
+					}
+				}
+			},
+		)
+	}
+}
+
+func TestMapResourceFields(t *testing.T) {
+	type given struct {
+		source *v3beta1api.GetDatabaseResponse
+		model  *resourceModel
+		region string
+	}
+	type expected struct {
+		model *resourceModel
+		err   bool
+	}
+
+	testcases := []struct {
+		name     string
+		given    given
+		expected expected
+	}{
+		{
+			name: "should map fields correctly",
+			given: given{
+				source: &v3beta1api.GetDatabaseResponse{
+					Id:    (int64(1)),
+					Name:  ("my-db"),
+					Owner: ("my-owner"),
+				},
+				model: &resourceModel{
+					ProjectId:  types.StringValue("my-project"),
+					InstanceId: types.StringValue("my-instance"),
+				},
+				region: "eu01",
+			},
+			expected: expected{
+				model: &resourceModel{
+					Id:                 types.Int64Value(1),
+					Name:               types.StringValue("my-db"),
+					Compatibility:      types.Int64Value(0),
+					CompatibilityLevel: types.Int64Value(0),
+					Collation:          types.StringValue(""),
+					CollationName:      types.StringValue(""),
+					DatabaseName:       types.StringValue("my-db"),
+					InstanceId:         types.StringValue("my-instance"),
+					ProjectId:          types.StringValue("my-project"),
+					Region:             types.StringValue("eu01"),
+					Owner:              types.StringValue("my-owner"),
+				},
+			},
+		},
+		{
+			name: "should fail on nil source",
+			given: given{
+				source: nil,
+				model:  &resourceModel{},
+			},
+			expected: expected{err: true},
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(
+			tc.name, func(t *testing.T) {
+				err := mapResourceFields(tc.given.source, tc.given.model, tc.given.region)
+				if (err != nil) != tc.expected.err {
+					t.Fatalf("expected error: %v, got: %v", tc.expected.err, err)
+				}
+				if err == nil {
+					if diff := cmp.Diff(tc.expected.model, tc.given.model); diff != "" {
+						t.Errorf("model mismatch (-want +got):\n%s", diff)
+					}
+				}
+			},
+		)
+	}
+}
+
+func TestToCreatePayload(t *testing.T) {
+	type given struct {
+		model *resourceModel
+	}
+	type expected struct {
+		payload *v3beta1api.CreateDatabaseRequestPayload
+		err     bool
+	}
+
+	testcases := []struct {
+		name     string
+		given    given
+		expected expected
+	}{
+		{
+			name: "should convert model to payload",
+			given: given{
+				model: &resourceModel{
+					Name:  types.StringValue("my-db"),
+					Owner: types.StringValue("my-owner"),
+				},
+			},
+			expected: expected{
+				payload: &v3beta1api.CreateDatabaseRequestPayload{
+					Name:          "my-db",
+					Owner:         "my-owner",
+					Compatibility: utils.Ptr(int32(0)),
+				},
+			},
+		},
+		{
+			name:     "should fail on nil model",
+			given:    given{model: nil},
+			expected: expected{err: true},
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(
+			tc.name, func(t *testing.T) {
+				actual, err := toCreatePayload(tc.given.model)
+				if (err != nil) != tc.expected.err {
+					t.Fatalf("expected error: %v, got: %v", tc.expected.err, err)
+				}
+				if err == nil {
+					if diff := cmp.Diff(tc.expected.payload, actual); diff != "" {
+						t.Errorf("payload mismatch (-want +got):\n%s", diff)
+					}
+				}
+			},
+		)
+	}
+}

stackit/internal/services/sqlserverflexbeta/database/planModifiers.yaml

@@ -0,0 +1,56 @@
+fields:
+  - name: 'id'
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'instance_id'
+    validators:
+      - validate.NoSeparator
+      - validate.UUID
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'project_id'
+    validators:
+      - validate.NoSeparator
+      - validate.UUID
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'region'
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'name'
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'collation'
+    modifiers:
+      - 'RequiresReplace'
+
+  - name: 'owner'
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'database_name'
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+
+  - name: 'collation_name'
+    modifiers:
+      - 'RequiresReplace'
+      - 'UseStateForUnknown'
+
+  - name: 'compatibility'
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'
+  
+  - name: 'compatibility_level'
+    modifiers:
+      - 'UseStateForUnknown'
+      - 'RequiresReplace'