Merge pull request #18 from the-hotels-network/DBE-5763

feat: allow find or set value in JSON using path like `a.b.c`.

Author: nicola-strappazzon

.github/workflows/go.yml

@@ -11,7 +11,7 @@ jobs:
     - name: Set up Go
       uses: actions/setup-go@v3
       with:
-        go-version: 1.19
+        go-version: 1.24
 
     - name: Format
       run: diff -u <(echo -n) <(gofmt -d ./)

README.md

@@ -7,6 +7,7 @@ A [Tinybird](https://www.tinybird.co/) module for Go. Why need this module? It p
 - Lightweight and fast.
 - Native Go implementation. No C-bindings, just pure Go
 - Connection pooling for HTTP.
+- Read and write values in nested JSON structures using path-based access.
 - Test your code with mocks.
 - Allow JSON, [NDJSON](http://ndjson.org/) and CSV between tinybird and this module.
 - Parallelize HTTP requests.

data.go

@@ -1,6 +1,10 @@
 package tinybird
 
-import "encoding/json"
+import (
+	"encoding/json"
+	"errors"
+	"strings"
+)
 
 // Row is a generic map-based structure that can hold fields of any type.
 // Each key corresponds to a field name, and each value can be any Go type.
@@ -41,3 +45,95 @@ func (d Data) ToString() (out string) {
 
 	return string(tmp)
 }
+
+// Get retrieves a value from the first row of the Data structure
+// by traversing a dot-separated path.
+//
+// The path represents nested keys within Row maps (e.g. "a.b.c").
+// If the Data slice is empty, the path does not exist, or an
+// intermediate value is not a Row, Get returns nil.
+func (d Data) Get(in string) any {
+	if len(d) == 0 {
+		return nil
+	}
+
+	parts := strings.Split(in, ".")
+
+	for _, row := range d {
+		if v, ok := get(row, parts); ok {
+			return v
+		}
+	}
+
+	return nil
+}
+
+func get(row Row, parts []string) (any, bool) {
+	var current any = row
+
+	for _, part := range parts {
+		r, ok := current.(Row)
+		if !ok {
+			return nil, false
+		}
+
+		current, ok = r[part]
+		if !ok {
+			return nil, false
+		}
+	}
+
+	return current, true
+}
+
+// Set assigns a value in the first row of the Data structure
+// at the location specified by a dot-separated path.
+//
+// Intermediate Row nodes are created as needed if they do not exist.
+// An error is returned if Data is empty, the path is empty, or
+// a non-Row value is encountered while traversing the path.
+func (d *Data) Set(in string, value any) error {
+	if d == nil {
+		return errors.New("nil Data")
+	}
+
+	parts := strings.Split(in, ".")
+
+	for i := range *d {
+		row := (*d)[i]
+
+		if _, ok := get(row, parts[:len(parts)-1]); ok {
+			return set(row, parts, value)
+		}
+	}
+
+	return errors.New("path not found")
+}
+
+func set(row Row, parts []string, value any) error {
+	current := row
+
+	for i, p := range parts {
+		if i == len(parts)-1 {
+			current[p] = value
+			return nil
+		}
+
+		next, exists := current[p]
+		if !exists {
+			child := Row{}
+			current[p] = child
+			current = child
+			continue
+		}
+
+		child, ok := next.(Row)
+		if !ok {
+			return errors.New("path collision at " + p)
+		}
+
+		current = child
+	}
+
+	return nil
+}

data_test.go

@@ -70,3 +70,44 @@ func TestToString_OnNilAndEmpty(t *testing.T) {
 	assert.Equal(t, "null", dNil.ToString())
 	assert.Equal(t, "[]", dEmpty.ToString())
 }
+
+func TestGet(t *testing.T) {
+	d := tinybird.Data{
+		{"a": nil},
+		{"b": tinybird.Row{"a": 1}},
+		{"b": tinybird.Row{"b": 2}},
+		{"b": tinybird.Row{"c": 3}},
+		{"c": tinybird.Row{"a": 4}},
+		{"d": tinybird.Row{"a": 5}},
+		{"d": tinybird.Row{"b": tinybird.Row{"a": 6}}},
+		{"f": 7},
+	}
+
+	assert.Nil(t, d.Get(""))
+	assert.Nil(t, d.Get("a"))
+	assert.Nil(t, d.Get("e"))
+	assert.Equal(t, 7, d.Get("f"))
+	assert.Equal(t, 4, d.Get("c.a"))
+	assert.Equal(t, 6, d.Get("d.b.a"))
+	assert.Equal(t, tinybird.Row{"a": 4}, d.Get("c"))
+}
+
+func TestSet(t *testing.T) {
+	d := tinybird.Data{
+		{"a": nil},
+		{"b": tinybird.Row{"a": 1}},
+		{"b": tinybird.Row{"b": 2}},
+		{"b": tinybird.Row{"c": 3}},
+		{"c": tinybird.Row{"a": 4}},
+		{"d": tinybird.Row{"a": 5}},
+		{"d": tinybird.Row{"b": tinybird.Row{"a": 6}}},
+		{"f": 7},
+	}
+
+	assert.Nil(t, d.Set("a", 0))
+	assert.Equal(t, 0, d.Get("a"))
+	assert.Nil(t, d.Set("b.b", 22))
+	assert.Equal(t, 22, d.Get("b.b"))
+	assert.Nil(t, d.Set("d.b.a", 66))
+	assert.Equal(t, 66, d.Get("d.b.a"))
+}