We want to reuse ip allowlist in postgres and keyvalue so we should pull it out of the service types (#349)

GitOrigin-RevId: 6b6c9de5dbf2d32297c1c0997f5fc4132cc04e6d

Author: mosslilley

pkg/service/clone.go

@@ -312,7 +312,7 @@ func formatIPAllowListEntries(entries []client.CidrBlockAndDescription) []string
 	}
 	parsed := make([]string, 0, len(entries))
 	for _, entry := range entries {
-		parsed = append(parsed, servicetypes.FormatIPAllowListEntry(entry.CidrBlock, entry.Description))
+		parsed = append(parsed, types.FormatIPAllowListEntry(entry.CidrBlock, entry.Description))
 	}
 	return parsed
 }

pkg/service/create.go

@@ -147,7 +147,7 @@ func buildServiceDetails(
 		if err != nil {
 			return nil, err
 		}
-		ipAllowList, err := parseIPAllowListInputs(cliInput.IPAllowList)
+		ipAllowList, err := ParseIPAllowListInputs(cliInput.IPAllowList)
 		if err != nil {
 			return nil, err
 		}
@@ -233,7 +233,7 @@ func buildServiceDetails(
 			return nil, err
 		}
 	case client.StaticSite:
-		ipAllowList, err := parseIPAllowListInputs(cliInput.IPAllowList)
+		ipAllowList, err := ParseIPAllowListInputs(cliInput.IPAllowList)
 		if err != nil {
 			return nil, err
 		}
@@ -370,13 +370,13 @@ func buildFilterFromInputs(paths []string, ignoredPaths []string) *client.BuildF
 	}
 }
 
-func parseIPAllowListInputs(raw []string) (*[]client.CidrBlockAndDescription, error) {
+func ParseIPAllowListInputs(raw []string) (*[]client.CidrBlockAndDescription, error) {
 	if len(raw) == 0 {
 		return nil, nil
 	}
 	entries := make([]client.CidrBlockAndDescription, 0, len(raw))
 	for _, entry := range raw {
-		cidr, description, err := servicetypes.ParseIPAllowListEntry(entry)
+		cidr, description, err := types.ParseIPAllowListEntry(entry)
 		if err != nil {
 			return nil, err
 		}

pkg/text/keyvalue.go

@@ -0,0 +1,19 @@
+package text
+
+import (
+	"github.com/render-oss/cli/pkg/client"
+)
+
+// KeyValueDetail formats a KV instance detail for text output.
+// Does NOT include an action prefix (e.g., "Created" or "Updated") — callers should prepend
+// their own action prefix in the formatText closure passed to command.NonInteractive.
+func KeyValueDetail(kv *client.KeyValueDetail) string {
+	return FormatStringF(
+		"Name: %s\nID: %s\nPlan: %s\nRegion: %s\nStatus: %s",
+		kv.Name,
+		kv.Id,
+		string(kv.Plan),
+		string(kv.Region),
+		string(kv.Status),
+	)
+}

pkg/types/service/ipallowlist.go pkg/types/ipallowlist.gopkg/types/service/ipallowlist.go renamed to pkg/types/ipallowlist.go

@@ -1,4 +1,4 @@
-package service
+package types
 
 import (
 	"fmt"

pkg/types/service/ipallowlist_test.go pkg/types/ipallowlist_test.gopkg/types/service/ipallowlist_test.go renamed to pkg/types/ipallowlist_test.go

@@ -1,85 +1,84 @@
-package service_test
+package types_test
 
 import (
 	"testing"
 
+	"github.com/render-oss/cli/pkg/types"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-
-	service "github.com/render-oss/cli/pkg/types/service"
 )
 
 func TestParseIPAllowListEntry(t *testing.T) {
 	t.Run("parses cidr with description", func(t *testing.T) {
-		cidr, desc, err := service.ParseIPAllowListEntry("cidr=10.0.0.0/8,description=Internal")
+		cidr, desc, err := types.ParseIPAllowListEntry("cidr=10.0.0.0/8,description=Internal")
 		require.NoError(t, err)
 		assert.Equal(t, "10.0.0.0/8", cidr)
 		assert.Equal(t, "Internal", desc)
 	})
 
 	t.Run("parses cidr without description", func(t *testing.T) {
-		cidr, desc, err := service.ParseIPAllowListEntry("cidr=10.0.0.0/8")
+		cidr, desc, err := types.ParseIPAllowListEntry("cidr=10.0.0.0/8")
 		require.NoError(t, err)
 		assert.Equal(t, "10.0.0.0/8", cidr)
 		assert.Equal(t, "", desc)
 	})
 
 	t.Run("handles IPv6 CIDR", func(t *testing.T) {
-		cidr, desc, err := service.ParseIPAllowListEntry("cidr=2001:db8::/32,description=IPv6 range")
+		cidr, desc, err := types.ParseIPAllowListEntry("cidr=2001:db8::/32,description=IPv6 range")
 		require.NoError(t, err)
 		assert.Equal(t, "2001:db8::/32", cidr)
 		assert.Equal(t, "IPv6 range", desc)
 	})
 
 	t.Run("rejects malformed input missing cidr key", func(t *testing.T) {
-		_, _, err := service.ParseIPAllowListEntry("malformed")
+		_, _, err := types.ParseIPAllowListEntry("malformed")
 		require.Error(t, err)
 		assert.Contains(t, err.Error(), "must start with cidr=")
 	})
 
 	t.Run("rejects empty cidr value", func(t *testing.T) {
-		_, _, err := service.ParseIPAllowListEntry("cidr=")
+		_, _, err := types.ParseIPAllowListEntry("cidr=")
 		require.Error(t, err)
 		assert.Contains(t, err.Error(), "cidr value is empty")
 	})
 
 	t.Run("rejects empty cidr value with description", func(t *testing.T) {
-		_, _, err := service.ParseIPAllowListEntry("cidr=,description=foo")
+		_, _, err := types.ParseIPAllowListEntry("cidr=,description=foo")
 		require.Error(t, err)
 		assert.Contains(t, err.Error(), "cidr value is empty")
 	})
 
 	t.Run("rejects invalid CIDR", func(t *testing.T) {
-		_, _, err := service.ParseIPAllowListEntry("cidr=not-a-cidr")
+		_, _, err := types.ParseIPAllowListEntry("cidr=not-a-cidr")
 		require.Error(t, err)
 		assert.Contains(t, err.Error(), "invalid CIDR")
 	})
 
 	t.Run("rejects IP without prefix length", func(t *testing.T) {
-		_, _, err := service.ParseIPAllowListEntry("cidr=10.0.0.1")
+		_, _, err := types.ParseIPAllowListEntry("cidr=10.0.0.1")
 		require.Error(t, err)
 		assert.Contains(t, err.Error(), "invalid CIDR")
 	})
 }
 
 func TestFormatIPAllowListEntry(t *testing.T) {
 	t.Run("formats cidr with description", func(t *testing.T) {
-		result := service.FormatIPAllowListEntry("10.0.0.0/8", "Internal")
+		result := types.FormatIPAllowListEntry("10.0.0.0/8", "Internal")
 		assert.Equal(t, "cidr=10.0.0.0/8,description=Internal", result)
 	})
 
 	t.Run("formats cidr without description", func(t *testing.T) {
-		result := service.FormatIPAllowListEntry("10.0.0.0/8", "")
+		result := types.FormatIPAllowListEntry("10.0.0.0/8", "")
 		assert.Equal(t, "cidr=10.0.0.0/8", result)
 	})
 
 	t.Run("formats IPv6 cidr with description", func(t *testing.T) {
-		result := service.FormatIPAllowListEntry("2001:db8::/32", "IPv6 range")
+		result := types.FormatIPAllowListEntry("2001:db8::/32", "IPv6 range")
 		assert.Equal(t, "cidr=2001:db8::/32,description=IPv6 range", result)
 	})
 
 	t.Run("formats IPv6 cidr without description", func(t *testing.T) {
-		result := service.FormatIPAllowListEntry("2001:db8::/32", "")
+		result := types.FormatIPAllowListEntry("2001:db8::/32", "")
 		assert.Equal(t, "cidr=2001:db8::/32", result)
 	})
 }

pkg/types/service/servicecreate.go

@@ -127,7 +127,7 @@ func (s ServiceCreateInput) validateNormalized(isInteractive bool) error {
 	}
 
 	for _, entry := range s.IPAllowList {
-		if _, _, err := ParseIPAllowListEntry(entry); err != nil {
+		if _, _, err := types.ParseIPAllowListEntry(entry); err != nil {
 			return err
 		}
 	}

pkg/types/service/serviceupdate.go

@@ -103,7 +103,7 @@ func (s ServiceUpdateInput) ValidateUpdate() error {
 		}
 	}
 	for _, entry := range s.IPAllowList {
-		if _, _, err := ParseIPAllowListEntry(entry); err != nil {
+		if _, _, err := types.ParseIPAllowListEntry(entry); err != nil {
 			return err
 		}
 	}