fix: Fixing #4556 (#5640)

* fix: Fixing #4556

* fix: Addressing empty behavior

Author: yhakbar

internal/tf/cache/controllers/provider.go

@@ -84,12 +84,17 @@ func (controller *ProviderController) getVersionsAction(ctx echo.Context) error
 		}
 	}
 
+	validVersions, invalidVersions := allVersions.FilterValid()
+	for _, v := range invalidVersions {
+		controller.Logger.Warnf("Skipping invalid version %q for provider %s", v, provider.Address())
+	}
+
 	versions := struct {
 		ID       string          `json:"id"`
 		Versions models.Versions `json:"versions"`
 	}{
 		ID:       provider.Address(),
-		Versions: allVersions,
+		Versions: validVersions,
 	}
 
 	return ctx.JSON(http.StatusOK, versions)

internal/tf/cache/models/provider.go

@@ -6,6 +6,8 @@ import (
 	"net/url"
 	"path"
 	"strings"
+
+	goversion "github.com/hashicorp/go-version"
 )
 
 type Providers []*Provider
@@ -64,6 +66,30 @@ func (version Version) String() string {
 	return fmt.Sprintf("%s/%s/%s", version.Version, version.Protocols, version.Platforms)
 }
 
+// FilterValid returns only versions with valid semver strings that conform to
+// the Terraform registry protocol (no "v" prefix, no empty strings).
+// The second return value contains the invalid version strings that were filtered out.
+func (versions Versions) FilterValid() (Versions, []string) {
+	valid := make(Versions, 0, len(versions))
+	invalid := make([]string, 0, len(versions))
+
+	for _, v := range versions {
+		if v.Version == "" || strings.HasPrefix(v.Version, "v") {
+			invalid = append(invalid, v.Version)
+			continue
+		}
+
+		if _, err := goversion.NewVersion(v.Version); err != nil {
+			invalid = append(invalid, v.Version)
+			continue
+		}
+
+		valid = append(valid, v)
+	}
+
+	return valid, invalid
+}
+
 type Platforms []*Platform
 
 type Platform struct {

internal/tf/cache/models/provider_test.go

@@ -10,6 +10,99 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+func TestFilterValid(t *testing.T) {
+	t.Parallel()
+
+	testCases := []struct {
+		name            string
+		input           models.Versions
+		expectedValid   []string
+		expectedInvalid []string
+	}{
+		{
+			name: "all valid versions",
+			input: models.Versions{
+				{Version: "1.0.0"},
+				{Version: "2.5.2"},
+				{Version: "0.1.0-beta1"},
+			},
+			expectedValid:   []string{"1.0.0", "2.5.2", "0.1.0-beta1"},
+			expectedInvalid: []string{},
+		},
+		{
+			name: "v-prefixed versions are filtered",
+			input: models.Versions{
+				{Version: "1.0.0"},
+				{Version: "v2.5.3"},
+				{Version: "v1.0.0"},
+			},
+			expectedValid:   []string{"1.0.0"},
+			expectedInvalid: []string{"v2.5.3", "v1.0.0"},
+		},
+		{
+			name: "empty strings are filtered",
+			input: models.Versions{
+				{Version: "1.0.0"},
+				{Version: ""},
+				{Version: "2.0.0"},
+			},
+			expectedValid:   []string{"1.0.0", "2.0.0"},
+			expectedInvalid: []string{""},
+		},
+		{
+			name: "garbage strings are filtered",
+			input: models.Versions{
+				{Version: "1.0.0"},
+				{Version: "not-a-version"},
+				{Version: "latest"},
+			},
+			expectedValid:   []string{"1.0.0"},
+			expectedInvalid: []string{"not-a-version", "latest"},
+		},
+		{
+			name: "mixed valid and invalid",
+			input: models.Versions{
+				{Version: "1.0.0"},
+				{Version: "v2.5.3-alpha1"},
+				{Version: ""},
+				{Version: "3.1.4"},
+				{Version: "not-a-version"},
+				{Version: "0.1.0-beta1"},
+			},
+			expectedValid:   []string{"1.0.0", "3.1.4", "0.1.0-beta1"},
+			expectedInvalid: []string{"v2.5.3-alpha1", "", "not-a-version"},
+		},
+		{
+			name:            "all invalid",
+			input:           models.Versions{{Version: "v1.0.0"}, {Version: ""}, {Version: "bad"}},
+			expectedValid:   []string{},
+			expectedInvalid: []string{"v1.0.0", "", "bad"},
+		},
+		{
+			name:            "empty input",
+			input:           models.Versions{},
+			expectedValid:   []string{},
+			expectedInvalid: []string{},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			valid, invalid := tc.input.FilterValid()
+
+			validStrs := make([]string, 0, len(valid))
+			for _, v := range valid {
+				validStrs = append(validStrs, v.Version)
+			}
+
+			assert.Equal(t, tc.expectedValid, validStrs)
+			assert.Equal(t, tc.expectedInvalid, invalid)
+		})
+	}
+}
+
 func TestResolveRelativeReferences(t *testing.T) {
 	t.Parallel()