NOISSUE - Update nullable handling (#2999)

dborovcanin · web-flow · commit be66701b1517 · 2025-07-04T17:34:31.000+02:00
Signed-off-by: Dusan Borovcanin &lt;borovcanindusan1@gmail.com&gt;
diff --git a/channels/postgres/channels.go b/channels/postgres/channels.go
@@ -1292,7 +1292,7 @@ func PageQuery(pm channels.Page) (string, error) {
 	if pm.Domain != "" {
 		query = append(query, "c.domain_id = :domain_id")
 	}
-	if pm.Group.Set {
+	if pm.Group.Valid {
 		switch {
 		case pm.Group.Value != "":
 			query = append(query, "c.parent_group_path <@ (SELECT path from groups where id = :group_id) ")
@@ -1360,7 +1360,7 @@ func toDBChannelsPage(pm channels.Page) (dbChannelsPage, error) {
 		Metadata:   data,
 		Tag:        pm.Tag,
 		Status:     pm.Status,
-		GroupID:    sql.NullString{Valid: pm.Group.Set, String: pm.Group.Value},
+		GroupID:    sql.NullString{Valid: pm.Group.Valid, String: pm.Group.Value},
 		ClientID:   pm.Client,
 		ConnType:   pm.ConnectionType,
 		RoleName:   pm.RoleName,
diff --git a/groups/api/grpc/endpoint_test.go b/groups/api/grpc/endpoint_test.go
@@ -30,7 +30,7 @@ const port = 7004
 var (
 	validID        = testsutil.GenerateUUID(&testing.T{})
 	valid          = "valid"
-	desc           = nullable.Value[string]{Set: true, Value: valid}
+	desc           = nullable.New(valid)
 	validGroupResp = groups.Group{
 		ID:          testsutil.GenerateUUID(&testing.T{}),
 		Name:        valid,
diff --git a/groups/api/http/endpoint_test.go b/groups/api/http/endpoint_test.go
@@ -32,7 +32,7 @@ import (
 )
 
 var (
-	desc           = nullable.Value[string]{Set: true, Value: valid}
+	desc           = nullable.New(valid)
 	validGroupResp = groups.Group{
 		ID:          testsutil.GenerateUUID(&testing.T{}),
 		Name:        valid,
diff --git a/groups/events/events.go b/groups/events/events.go
@@ -78,7 +78,7 @@ func (cge createGroupEvent) Encode() (map[string]interface{}, error) {
 	if cge.Name != "" {
 		val["name"] = cge.Name
 	}
-	if cge.Description.Set {
+	if cge.Description.Valid {
 		val["description"] = cge.Description
 	}
 	if cge.Metadata != nil {
@@ -120,7 +120,7 @@ func (uge updateGroupEvent) Encode() (map[string]interface{}, error) {
 	if uge.Name != "" {
 		val["name"] = uge.Name
 	}
-	if uge.Description.Set {
+	if uge.Description.Valid {
 		val["description"] = uge.Description
 	}
 	if uge.Metadata != nil {
@@ -184,7 +184,7 @@ func (vge viewGroupEvent) Encode() (map[string]interface{}, error) {
 	if vge.Name != "" {
 		val["name"] = vge.Name
 	}
-	if vge.Description.Set {
+	if vge.Description.Valid {
 		val["description"] = vge.Description
 	}
 	if vge.Metadata != nil {
diff --git a/groups/postgres/groups.go b/groups/postgres/groups.go
@@ -85,7 +85,7 @@ func (repo groupRepository) Update(ctx context.Context, g groups.Group) (groups.
 	if g.Name != "" {
 		query = append(query, "name = :name,")
 	}
-	if g.Description.Set {
+	if g.Description.Valid {
 		query = append(query, "description = :description,")
 	}
 	if g.Metadata != nil {
@@ -1207,7 +1207,7 @@ func toDBGroup(g groups.Group) (dbGroup, error) {
 		Name:        g.Name,
 		ParentID:    parentID,
 		DomainID:    g.Domain,
-		Description: sql.NullString{String: g.Description.Value, Valid: g.Description.Set},
+		Description: sql.NullString{String: g.Description.Value, Valid: g.Description.Valid},
 		Tags:        tags,
 		Metadata:    data,
 		Path:        g.Path,
@@ -1254,7 +1254,7 @@ func toGroup(g dbGroup) (groups.Group, error) {
 		Name:                      g.Name,
 		Parent:                    parentID,
 		Domain:                    g.DomainID,
-		Description:               nullable.Value[string]{Value: g.Description.String, Set: g.Description.Valid},
+		Description:               nullable.Value[string]{Value: g.Description.String, Valid: g.Description.Valid},
 		Tags:                      tags,
 		Metadata:                  metadata,
 		Level:                     g.Level,
diff --git a/groups/postgres/groups_test.go b/groups/postgres/groups_test.go
@@ -27,9 +27,9 @@ var (
 	invalidID          = strings.Repeat("a", 37)
 	validTimestamp     = time.Now().UTC().Truncate(time.Millisecond)
 	description        = strings.Repeat("a", 64)
-	desc               = nullable.Value[string]{Set: true, Value: description}
+	desc               = nullable.New(description)
 	invalidDescription = strings.Repeat("a", 1025)
-	invalidDesc        = nullable.Value[string]{Set: true, Value: invalidDescription}
+	invalidDesc        = nullable.New(invalidDescription)
 
 	validGroup = groups.Group{
 		ID:          testsutil.GenerateUUID(&testing.T{}),
diff --git a/groups/service_test.go b/groups/service_test.go
@@ -36,7 +36,7 @@ var (
 	idProvider  = uuid.New()
 	namegen     = namegenerator.NewGenerator()
 	description = namegen.Generate()
-	desc        = nullable.Value[string]{Set: true, Value: description}
+	desc        = nullable.Value[string]{Valid: true, Value: description}
 	validGroup  = groups.Group{
 		ID:          testsutil.GenerateUUID(&testing.T{}),
 		Name:        namegen.Generate(),
diff --git a/internal/nullable/bench_test.go b/internal/nullable/bench_test.go
@@ -23,11 +23,11 @@ func BenchmarkPointerString(b *testing.B) {
 
 func BenchmarkNullableString(b *testing.B) {
 	n := func() Value[string] {
-		return Value[string]{Set: true, Value: "test"}
+		return Value[string]{Valid: true, Value: "test"}
 	}()
 
 	for b.Loop() {
-		if n.Set {
+		if n.Valid {
 			_ = n.Value + "test"
 		}
 	}
@@ -66,11 +66,11 @@ func BenchmarkPointerInt(b *testing.B) {
 
 func BenchmarkNullableInt(b *testing.B) {
 	n := func() Value[int] {
-		return Value[int]{Set: true, Value: 42}
+		return Value[int]{Valid: true, Value: 42}
 	}()
 
 	for b.Loop() {
-		if n.Set {
+		if n.Valid {
 			_ = n.Value + 1
 		}
 	}
@@ -113,11 +113,11 @@ func BenchmarkPointerFloat(b *testing.B) {
 
 func BenchmarkNullableFloat(b *testing.B) {
 	n := func() Value[float64] {
-		return Value[float64]{Set: true, Value: 42}
+		return Value[float64]{Valid: true, Value: 42}
 	}()
 
 	for b.Loop() {
-		if n.Set {
+		if n.Valid {
 			_ = n.Value + 1
 		}
 	}
diff --git a/internal/nullable/parsers.go b/internal/nullable/parsers.go
@@ -11,7 +11,11 @@ import (
 
 var ErrInvalidQueryParams = errors.New("invalid query parameters")
 
-func Parse[T any](q url.Values, key string, parser FromString[T]) (Value[T], error) {
+type nullable interface {
+	~string | ~int | ~uint | ~float64
+}
+
+func Parse[T nullable](q url.Values, key string, parser Parser[T]) (Value[T], error) {
 	vals, ok := q[key]
 	if !ok {
 		return Value[T]{}, nil
@@ -22,51 +26,51 @@ func Parse[T any](q url.Values, key string, parser FromString[T]) (Value[T], err
 	s := vals[0]
 	if s == "" {
 		// The actual value is sent in query, so nullable is set, but empty.
-		return Value[T]{Set: true}, nil
+		return Value[T]{Valid: true}, nil
 	}
 	return parser(s)
 }
 
 func ParseString(s string) (Value[string], error) {
-	return Value[string]{Set: true, Value: s}, nil
+	return Value[string]{Valid: true, Value: s}, nil
 }
 
 func ParseInt(s string) (Value[int], error) {
 	val, err := strconv.Atoi(s)
 	if err != nil {
 		return Value[int]{}, err
 	}
-	return Value[int]{Set: true, Value: val}, nil
+	return Value[int]{Valid: true, Value: val}, nil
 }
 
 func ParseFloat(s string) (Value[float64], error) {
 	val, err := strconv.ParseFloat(s, 64)
 	if err != nil {
 		return Value[float64]{}, err
 	}
-	return Value[float64]{Set: true, Value: val}, nil
+	return Value[float64]{Valid: true, Value: val}, nil
 }
 
 func ParseBool(s string) (Value[bool], error) {
 	b, err := strconv.ParseBool(s)
 	if err != nil {
 		return Value[bool]{}, err
 	}
-	return Value[bool]{Set: true, Value: b}, nil
+	return Value[bool]{Valid: true, Value: b}, nil
 }
 
 func ParseU16(s string) (Value[uint16], error) {
 	val, err := strconv.ParseUint(s, 10, 16)
 	if err != nil {
 		return Value[uint16]{}, err
 	}
-	return Value[uint16]{Set: true, Value: uint16(val)}, nil
+	return Value[uint16]{Valid: true, Value: uint16(val)}, nil
 }
 
 func ParseU64(s string) (Value[uint64], error) {
 	val, err := strconv.ParseUint(s, 10, 64)
 	if err != nil {
 		return Value[uint64]{}, err
 	}
-	return Value[uint64]{Set: true, Value: val}, nil
+	return Value[uint64]{Valid: true, Value: val}, nil
 }
diff --git a/internal/nullable/parsers_test.go b/internal/nullable/parsers_test.go
@@ -13,59 +13,59 @@ func TestParseHelpers(t *testing.T) {
 	t.Run("ParseString", func(t *testing.T) {
 		val, err := ParseString("hello")
 		assert.NoError(t, err)
-		assert.True(t, val.Set)
+		assert.True(t, val.Valid)
 		assert.Equal(t, "hello", val.Value)
 	})
 
 	t.Run("ParseInt", func(t *testing.T) {
 		val, err := ParseInt("42")
 		assert.NoError(t, err)
-		assert.True(t, val.Set)
+		assert.True(t, val.Valid)
 		assert.Equal(t, 42, val.Value)
 
 		val, err = ParseInt("notanint")
 		assert.Error(t, err)
-		assert.False(t, val.Set)
+		assert.False(t, val.Valid)
 	})
 
 	t.Run("ParseFloat", func(t *testing.T) {
 		val, err := ParseFloat("3.14")
 		assert.NoError(t, err)
-		assert.True(t, val.Set)
+		assert.True(t, val.Valid)
 		assert.Equal(t, 3.14, val.Value)
 	})
 
 	t.Run("ParseBool", func(t *testing.T) {
 		val, err := ParseBool("true")
 		assert.NoError(t, err)
-		assert.True(t, val.Set)
+		assert.True(t, val.Valid)
 		assert.True(t, val.Value)
 
 		val, err = ParseBool("false")
 		assert.NoError(t, err)
-		assert.True(t, val.Set)
+		assert.True(t, val.Valid)
 		assert.False(t, val.Value)
 
 		val, err = ParseBool("maybe")
 		assert.Error(t, err)
-		assert.False(t, val.Set)
+		assert.False(t, val.Valid)
 	})
 
 	t.Run("ParseU16", func(t *testing.T) {
 		val, err := ParseU16("65535")
 		assert.NoError(t, err)
-		assert.True(t, val.Set)
+		assert.True(t, val.Valid)
 		assert.Equal(t, uint16(65535), val.Value)
 
 		val, err = ParseU16("70000")
 		assert.Error(t, err)
-		assert.False(t, val.Set)
+		assert.False(t, val.Valid)
 	})
 
 	t.Run("ParseU64", func(t *testing.T) {
 		val, err := ParseU64("1234567890")
 		assert.NoError(t, err)
-		assert.True(t, val.Set)
+		assert.True(t, val.Valid)
 		assert.Equal(t, uint64(1234567890), val.Value)
 	})
 }
@@ -86,21 +86,21 @@ func TestParseQueryParam(t *testing.T) {
 			query:  url.Values{},
 			key:    "limit",
 			parser: ParseInt,
-			expect: Value[int]{Set: false},
+			expect: Value[int]{Valid: false},
 		},
 		{
 			name:   "empty value",
 			query:  url.Values{"limit": {""}},
 			key:    "limit",
 			parser: ParseInt,
-			expect: Value[int]{Set: true},
+			expect: Value[int]{Valid: true},
 		},
 		{
 			name:   "valid int",
 			query:  url.Values{"limit": {"10"}},
 			key:    "limit",
 			parser: ParseInt,
-			expect: Value[int]{Set: true, Value: 10},
+			expect: Value[int]{Valid: true, Value: 10},
 		},
 		{
 			name:      "invalid int",
diff --git a/internal/nullable/value.go b/internal/nullable/value.go
@@ -12,18 +12,25 @@ import (
 // Value type is used to represent difference betweeen an
 // intentionally omitted value and default type value.
 type Value[T any] struct {
-	Set   bool
+	Valid bool
 	Value T
 }
 
-// FromString[T any] represents a parser function. It is used to avoid
+func New[T nullable](v T) Value[T] {
+	return Value[T]{
+		Valid: true,
+		Value: v,
+	}
+}
+
+// Parser[T any] represents a parser function. It is used to avoid
 // a single parser for all nullables for improved readability and performance.
-// FromString should always return Nullable with Set=true, error otherwise.
-type FromString[T any] func(string) (Value[T], error)
+// Parser should always return Nullable with Set=true, error otherwise.
+type Parser[T nullable] func(string) (Value[T], error)
 
 // MarshalJSON encodes the value if set, otherwise returns `null`.
 func (n Value[T]) MarshalJSON() ([]byte, error) {
-	if !n.Set {
+	if !n.Valid {
 		return []byte("null"), nil
 	}
 	return json.Marshal(n.Value)
@@ -32,7 +39,7 @@ func (n Value[T]) MarshalJSON() ([]byte, error) {
 // UnmarshalJSON decodes JSON and sets the value and Set flag.
 func (n *Value[T]) UnmarshalJSON(data []byte) error {
 	if bytes.Equal(data, []byte("null")) {
-		n.Set = false
+		n.Valid = false
 		var empty T
 		n.Value = empty
 		return nil
@@ -43,6 +50,6 @@ func (n *Value[T]) UnmarshalJSON(data []byte) error {
 		return fmt.Errorf("nullable: failed to unmarshal: %w", err)
 	}
 	n.Value = val
-	n.Set = true
+	n.Valid = true
 	return nil
 }
diff --git a/pkg/groups/events/consumer/decode.go b/pkg/groups/events/consumer/decode.go
@@ -34,9 +34,7 @@ var (
 	errUpdatedAt     = errors.New("failed to parse 'updated_at' time")
 )
 
-const (
-	layout = "2006-01-02T15:04:05.999999Z"
-)
+const layout = "2006-01-02T15:04:05.999999Z"
 
 func ToGroups(data map[string]interface{}) (groups.Group, error) {
 	var g groups.Group
@@ -82,7 +80,7 @@ func ToGroups(data map[string]interface{}) (groups.Group, error) {
 
 	desc, ok := data["description"].(string)
 	if ok {
-		g.Description = nullable.Value[string]{Set: true, Value: desc}
+		g.Description = nullable.New(desc)
 	}
 
 	parent, ok := data["parent"].(string)
diff --git a/pkg/sdk/groups_test.go b/pkg/sdk/groups_test.go
diff --git a/pkg/sdk/setup_test.go b/pkg/sdk/setup_test.go

Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ import (`
`32`	`32`	`)`
`33`	`33`
`34`	`34`	`var (`
`35`		`- desc = nullable.Value[string]{Set: true, Value: valid}`
	`35`	`+ desc = nullable.New(valid)`
`36`	`36`	`validGroupResp = groups.Group{`
`37`	`37`	`ID: testsutil.GenerateUUID(&testing.T{}),`
`38`	`38`	`Name: valid,`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ func (cge createGroupEvent) Encode() (map[string]interface{}, error) {`
`78`	`78`	`if cge.Name != "" {`
`79`	`79`	`val["name"] = cge.Name`
`80`	`80`	`}`
`81`		`- if cge.Description.Set {`
	`81`	`+ if cge.Description.Valid {`
`82`	`82`	`val["description"] = cge.Description`
`83`	`83`	`}`
`84`	`84`	`if cge.Metadata != nil {`
`@@ -120,7 +120,7 @@ func (uge updateGroupEvent) Encode() (map[string]interface{}, error) {`
`120`	`120`	`if uge.Name != "" {`
`121`	`121`	`val["name"] = uge.Name`
`122`	`122`	`}`
`123`		`- if uge.Description.Set {`
	`123`	`+ if uge.Description.Valid {`
`124`	`124`	`val["description"] = uge.Description`
`125`	`125`	`}`
`126`	`126`	`if uge.Metadata != nil {`
`@@ -184,7 +184,7 @@ func (vge viewGroupEvent) Encode() (map[string]interface{}, error) {`
`184`	`184`	`if vge.Name != "" {`
`185`	`185`	`val["name"] = vge.Name`
`186`	`186`	`}`
`187`		`- if vge.Description.Set {`
	`187`	`+ if vge.Description.Valid {`
`188`	`188`	`val["description"] = vge.Description`
`189`	`189`	`}`
`190`	`190`	`if vge.Metadata != nil {`
Original file line number	Diff line number	Diff line change
`@@ -23,11 +23,11 @@ func BenchmarkPointerString(b *testing.B) {`
`23`	`23`
`24`	`24`	`func BenchmarkNullableString(b *testing.B) {`
`25`	`25`	`n := func() Value[string] {`
`26`		`- return Value[string]{Set: true, Value: "test"}`
	`26`	`+ return Value[string]{Valid: true, Value: "test"}`
`27`	`27`	`}()`
`28`	`28`
`29`	`29`	`for b.Loop() {`
`30`		`- if n.Set {`
	`30`	`+ if n.Valid {`
`31`	`31`	`_ = n.Value + "test"`
`32`	`32`	`}`
`33`	`33`	`}`
`@@ -66,11 +66,11 @@ func BenchmarkPointerInt(b *testing.B) {`
`66`	`66`
`67`	`67`	`func BenchmarkNullableInt(b *testing.B) {`
`68`	`68`	`n := func() Value[int] {`
`69`		`- return Value[int]{Set: true, Value: 42}`
	`69`	`+ return Value[int]{Valid: true, Value: 42}`
`70`	`70`	`}()`
`71`	`71`
`72`	`72`	`for b.Loop() {`
`73`		`- if n.Set {`
	`73`	`+ if n.Valid {`
`74`	`74`	`_ = n.Value + 1`
`75`	`75`	`}`
`76`	`76`	`}`
`@@ -113,11 +113,11 @@ func BenchmarkPointerFloat(b *testing.B) {`
`113`	`113`
`114`	`114`	`func BenchmarkNullableFloat(b *testing.B) {`
`115`	`115`	`n := func() Value[float64] {`
`116`		`- return Value[float64]{Set: true, Value: 42}`
	`116`	`+ return Value[float64]{Valid: true, Value: 42}`
`117`	`117`	`}()`
`118`	`118`
`119`	`119`	`for b.Loop() {`
`120`		`- if n.Set {`
	`120`	`+ if n.Valid {`
`121`	`121`	`_ = n.Value + 1`
`122`	`122`	`}`
`123`	`123`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,11 @@ import (`
`11`	`11`
`12`	`12`	`var ErrInvalidQueryParams = errors.New("invalid query parameters")`
`13`	`13`
`14`		`-func Parse[T any](q url.Values, key string, parser FromString[T]) (Value[T], error) {`
	`14`	`+type nullable interface {`
	`15`	`+ ~string \| ~int \| ~uint \| ~float64`
	`16`	`+}`
	`17`	`+`
	`18`	`+func Parse[T nullable](q url.Values, key string, parser Parser[T]) (Value[T], error) {`
`15`	`19`	`vals, ok := q[key]`
`16`	`20`	`if !ok {`
`17`	`21`	`return Value[T]{}, nil`
`@@ -22,51 +26,51 @@ func Parse[T any](q url.Values, key string, parser FromString[T]) (Value[T], err`
`22`	`26`	`s := vals[0]`
`23`	`27`	`if s == "" {`
`24`	`28`	`// The actual value is sent in query, so nullable is set, but empty.`
`25`		`- return Value[T]{Set: true}, nil`
	`29`	`+ return Value[T]{Valid: true}, nil`
`26`	`30`	`}`
`27`	`31`	`return parser(s)`
`28`	`32`	`}`
`29`	`33`
`30`	`34`	`func ParseString(s string) (Value[string], error) {`
`31`		`- return Value[string]{Set: true, Value: s}, nil`
	`35`	`+ return Value[string]{Valid: true, Value: s}, nil`
`32`	`36`	`}`
`33`	`37`
`34`	`38`	`func ParseInt(s string) (Value[int], error) {`
`35`	`39`	`val, err := strconv.Atoi(s)`
`36`	`40`	`if err != nil {`
`37`	`41`	`return Value[int]{}, err`
`38`	`42`	`}`
`39`		`- return Value[int]{Set: true, Value: val}, nil`
	`43`	`+ return Value[int]{Valid: true, Value: val}, nil`
`40`	`44`	`}`
`41`	`45`
`42`	`46`	`func ParseFloat(s string) (Value[float64], error) {`
`43`	`47`	`val, err := strconv.ParseFloat(s, 64)`
`44`	`48`	`if err != nil {`
`45`	`49`	`return Value[float64]{}, err`
`46`	`50`	`}`
`47`		`- return Value[float64]{Set: true, Value: val}, nil`
	`51`	`+ return Value[float64]{Valid: true, Value: val}, nil`
`48`	`52`	`}`
`49`	`53`
`50`	`54`	`func ParseBool(s string) (Value[bool], error) {`
`51`	`55`	`b, err := strconv.ParseBool(s)`
`52`	`56`	`if err != nil {`
`53`	`57`	`return Value[bool]{}, err`
`54`	`58`	`}`
`55`		`- return Value[bool]{Set: true, Value: b}, nil`
	`59`	`+ return Value[bool]{Valid: true, Value: b}, nil`
`56`	`60`	`}`
`57`	`61`
`58`	`62`	`func ParseU16(s string) (Value[uint16], error) {`
`59`	`63`	`val, err := strconv.ParseUint(s, 10, 16)`
`60`	`64`	`if err != nil {`
`61`	`65`	`return Value[uint16]{}, err`
`62`	`66`	`}`
`63`		`- return Value[uint16]{Set: true, Value: uint16(val)}, nil`
	`67`	`+ return Value[uint16]{Valid: true, Value: uint16(val)}, nil`
`64`	`68`	`}`
`65`	`69`
`66`	`70`	`func ParseU64(s string) (Value[uint64], error) {`
`67`	`71`	`val, err := strconv.ParseUint(s, 10, 64)`
`68`	`72`	`if err != nil {`
`69`	`73`	`return Value[uint64]{}, err`
`70`	`74`	`}`
`71`		`- return Value[uint64]{Set: true, Value: val}, nil`
	`75`	`+ return Value[uint64]{Valid: true, Value: val}, nil`
`72`	`76`	`}`