feat(go): add methods to Field

go/model.go

@@ -292,45 +292,35 @@ type Field struct {
 }
 
 func (f *Field) ValueString() *string {
-	if f == nil {
-		return nil
-	}
-
-	if v, ok := f.Value.(string); ok {
-		return &v
-	}
-
-	return nil
+	return FieldValue[string](f)
 }
 
 func (f *Field) ValueStrings() []string {
-	if f == nil {
-		return nil
-	}
-
-	if v, ok := f.Value.([]string); ok {
-		return v
-	}
+	return FieldValues[string](f)
+}
 
-	if v, ok := f.Value.([]any); ok {
-		return lo.FilterMap(v, func(e any, _ int) (string, bool) {
-			s, ok := e.(string)
-			return s, ok
-		})
-	}
+func (f *Field) ValueBool() *bool {
+	return FieldValue[bool](f)
+}
 
-	return nil
+func (f *Field) ValueBools() []bool {
+	return FieldValues[bool](f)
 }
 
 func (f *Field) ValueInt() *int {
-	if f == nil {
-		return nil
-	}
+	return FieldValue[int](f)
+}
 
-	if v, ok := f.Value.(int); ok {
-		return &v
-	}
-	return nil
+func (f *Field) ValueInts() []int {
+	return FieldValues[int](f)
+}
+
+func (f *Field) ValueFloat() *float64 {
+	return FieldValue[float64](f)
+}
+
+func (f *Field) ValueFloats() []float64 {
+	return FieldValues[float64](f)
 }
 
 func (f *Field) ValueJSON() (any, error) {
@@ -347,6 +337,26 @@ func (f *Field) ValueJSON() (any, error) {
 	return j, err
 }
 
+func (f *Field) ValueJSONs() ([]any, error) {
+	if f == nil {
+		return nil, nil
+	}
+	values := f.ValueStrings()
+	if values == nil {
+		return nil, nil
+	}
+
+	var res []any
+	for _, v := range values {
+		var r any
+		if err := json.Unmarshal([]byte(v), &r); err != nil {
+			return nil, err
+		}
+		res = append(res, r)
+	}
+	return res, nil
+}
+
 func (f *Field) Clone() *Field {
 	if f == nil {
 		return nil
@@ -359,6 +369,37 @@ func (f *Field) Clone() *Field {
 	}
 }
 
+func FieldValue[T any](f *Field) *T {
+	if f == nil {
+		return nil
+	}
+
+	if v, ok := f.Value.(T); ok {
+		return &v
+	}
+
+	return nil
+}
+
+func FieldValues[T any](f *Field) []T {
+	if f == nil {
+		return nil
+	}
+
+	if v, ok := f.Value.([]T); ok {
+		return v
+	}
+
+	if v, ok := f.Value.([]any); ok {
+		return lo.FilterMap(v, func(e any, _ int) (T, bool) {
+			s, ok := e.(T)
+			return s, ok
+		})
+	}
+
+	return nil
+}
+
 type Schema struct {
 	ID        string        `json:"id"`
 	Fields    []SchemaField `json:"fields"`

go/model_test.go

@@ -184,6 +184,15 @@ func TestField_ValueStrings(t *testing.T) {
 	}).ValueStrings())
 }
 
+func TestField_ValueBool(t *testing.T) {
+	assert.Equal(t, lo.ToPtr(true), (&Field{
+		Value: true,
+	}).ValueBool())
+	assert.Nil(t, (&Field{
+		Value: 1,
+	}).ValueBool())
+}
+
 func TestField_ValueInt(t *testing.T) {
 	assert.Equal(t, lo.ToPtr(100), (&Field{
 		Value: 100,
@@ -193,6 +202,18 @@ func TestField_ValueInt(t *testing.T) {
 	}).ValueInt())
 }
 
+func TestField_ValueFloat(t *testing.T) {
+	assert.Equal(t, lo.ToPtr(100.1), (&Field{
+		Value: 100.1,
+	}).ValueFloat())
+	assert.Nil(t, (&Field{
+		Value: 100,
+	}).ValueFloat())
+	assert.Nil(t, (&Field{
+		Value: "100.1",
+	}).ValueFloat())
+}
+
 func TestField_ValueJSON(t *testing.T) {
 	r, err := (&Field{
 		Value: `{"foo":"bar"}`,
@@ -201,6 +222,14 @@ func TestField_ValueJSON(t *testing.T) {
 	assert.Equal(t, map[string]any{"foo": "bar"}, r)
 }
 
+func TestField_ValueJSONs(t *testing.T) {
+	r, err := (&Field{
+		Value: []string{`{"foo":"bar"}`, `{"foo":"hoge"}`},
+	}).ValueJSONs()
+	assert.NoError(t, err)
+	assert.Equal(t, []any{map[string]any{"foo": "bar"}, map[string]any{"foo": "hoge"}}, r)
+}
+
 func TestItems_HasNext(t *testing.T) {
 	assert.True(t, Items{Page: 1, PerPage: 50, TotalCount: 100}.HasNext())
 	assert.False(t, Items{Page: 2, PerPage: 50, TotalCount: 100}.HasNext())