Share IP allow-list request parsing (#438)

We already have a shared utility to parse a single `--ip-allow-list` value.
This factors logic out of the keyvalue package to parse the result when a user supplies multiple.

GitOrigin-RevId: f02d85f3c874752093f3453a5e9002656d5bec01

Author: davidharting

pkg/keyvalue/create.go

@@ -129,7 +129,7 @@ func BuildCreateRequest(input kvtypes.KeyValueCreateRequestInput) (client.Create
 	}
 
 	if len(input.IPAllowList) > 0 {
-		entries, err := parseIPAllowList(input.IPAllowList)
+		entries, err := types.ParseIPAllowList(input.IPAllowList)
 		if err != nil {
 			return client.CreateKeyValueJSONRequestBody{}, err
 		}
@@ -138,18 +138,3 @@ func BuildCreateRequest(input kvtypes.KeyValueCreateRequestInput) (client.Create
 
 	return body, nil
 }
-
-func parseIPAllowList(raw []string) ([]client.CidrBlockAndDescription, error) {
-	out := make([]client.CidrBlockAndDescription, 0, len(raw))
-	for _, entry := range raw {
-		cidr, desc, err := types.ParseIPAllowListEntry(entry)
-		if err != nil {
-			return nil, err
-		}
-		out = append(out, client.CidrBlockAndDescription{
-			CidrBlock:   cidr,
-			Description: desc,
-		})
-	}
-	return out, nil
-}

pkg/keyvalue/update.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"github.com/render-oss/cli/pkg/client"
+	"github.com/render-oss/cli/pkg/types"
 	kvtypes "github.com/render-oss/cli/pkg/types/keyvalue"
 )
 
@@ -82,7 +83,7 @@ func BuildUpdateRequest(input kvtypes.KeyValueUpdateInput) (client.UpdateKeyValu
 	}
 
 	if len(input.IPAllowList) > 0 {
-		entries, err := parseIPAllowList(input.IPAllowList)
+		entries, err := types.ParseIPAllowList(input.IPAllowList)
 		if err != nil {
 			return client.UpdateKeyValueJSONRequestBody{}, err
 		}

pkg/service/create.go

@@ -374,16 +374,9 @@ func ParseIPAllowListInputs(raw []string) (*[]client.CidrBlockAndDescription, er
 	if len(raw) == 0 {
 		return nil, nil
 	}
-	entries := make([]client.CidrBlockAndDescription, 0, len(raw))
-	for _, entry := range raw {
-		cidr, description, err := types.ParseIPAllowListEntry(entry)
-		if err != nil {
-			return nil, err
-		}
-		entries = append(entries, client.CidrBlockAndDescription{
-			CidrBlock:   cidr,
-			Description: description,
-		})
+	entries, err := types.ParseIPAllowList(raw)
+	if err != nil {
+		return nil, err
 	}
 	return &entries, nil
 }

pkg/types/ipallowlist.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"net"
 	"strings"
+
+	"github.com/render-oss/cli/pkg/client"
 )
 
 // ParseIPAllowListEntry parses an AWS-style composite flag value into a CIDR block and description.
@@ -43,6 +45,24 @@ func ParseIPAllowListEntry(raw string) (cidrBlock string, description string, er
 	return cidrBlock, description, nil
 }
 
+// ParseIPAllowList parses a list of --ip-allow-list flag values into the REST
+// API shape. Each entry follows the format documented on
+// ParseIPAllowListEntry.
+func ParseIPAllowList(raw []string) ([]client.CidrBlockAndDescription, error) {
+	out := make([]client.CidrBlockAndDescription, 0, len(raw))
+	for _, entry := range raw {
+		cidr, desc, err := ParseIPAllowListEntry(entry)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, client.CidrBlockAndDescription{
+			CidrBlock:   cidr,
+			Description: desc,
+		})
+	}
+	return out, nil
+}
+
 // FormatIPAllowListEntry formats a CIDR block and description into the composite flag format.
 func FormatIPAllowListEntry(cidrBlock, description string) string {
 	if description != "" {

pkg/types/ipallowlist_test.go

@@ -61,6 +61,33 @@ func TestParseIPAllowListEntry(t *testing.T) {
 	})
 }
 
+func TestParseIPAllowList(t *testing.T) {
+	t.Run("parses each entry into a CidrBlockAndDescription", func(t *testing.T) {
+		out, err := types.ParseIPAllowList([]string{
+			"cidr=10.0.0.0/8,description=Internal",
+			"cidr=203.0.113.5/32",
+		})
+		require.NoError(t, err)
+		require.Len(t, out, 2)
+		assert.Equal(t, "10.0.0.0/8", out[0].CidrBlock)
+		assert.Equal(t, "Internal", out[0].Description)
+		assert.Equal(t, "203.0.113.5/32", out[1].CidrBlock)
+		assert.Equal(t, "", out[1].Description)
+	})
+
+	t.Run("propagates entry-level errors", func(t *testing.T) {
+		_, err := types.ParseIPAllowList([]string{"malformed"})
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "must start with cidr=")
+	})
+
+	t.Run("nil input yields empty slice", func(t *testing.T) {
+		out, err := types.ParseIPAllowList(nil)
+		require.NoError(t, err)
+		assert.Empty(t, out)
+	})
+}
+
 func TestFormatIPAllowListEntry(t *testing.T) {
 	t.Run("formats cidr with description", func(t *testing.T) {
 		result := types.FormatIPAllowListEntry("10.0.0.0/8", "Internal")