Open platform to collect and prioritize feedback
package jsonq
import (
"encoding/json"
"strconv"
"strings"
)
//Query is a JSON query interface
type Query struct {
json string
m map[string]*json.RawMessage
}
//New creates a new Query object based on given input as a JSON
func New(content string) *Query {
var m map[string]*json.RawMessage
if len(content) > 0 && content[:1] == "{" {
err := json.Unmarshal([]byte(content), &m)
if err != nil {
panic(err)
}
}
return &Query{
m: m,
json: content,
}
}
//String returns a string value from the json object based on its selector
func (q *Query) String(selector string) string {
selectors := strings.Split(selector, ",")
for _, s := range selectors {
data := q.get(strings.TrimSpace(s))
if data != nil {
var str string
if err := json.Unmarshal(*data, &str); err == nil && str != "" {
return str
}
var num int
if err := json.Unmarshal(*data, &num); err == nil {
return strconv.Itoa(num)
}
}
}
return ""
}
//Int32 returns a integer value from the json object based on its selector
func (q *Query) Int32(selector string) int {
data := q.get(selector)
if data != nil {
var num int
err := json.Unmarshal(*data, &num)
if err != nil {
panic(err)
}
return num
}
return 0
}
//IsArray returns true if the json object is an array
func (q *Query) IsArray() bool {
return q.m == nil
}
//ArrayLength returns number of elements in the array
func (q *Query) ArrayLength() int {
if q.IsArray() {
var arr []any
err := json.Unmarshal([]byte(q.json), &arr)
if err != nil {
panic(err)
}
return len(arr)
}
return 0
}
//Contains returns true if the json object has the key
func (q *Query) Contains(selector string) bool {
return q.get(selector) != nil
}
//Raw returns the raw JSON bytes at the given dot-notation selector, or nil if not found.
func (q *Query) Raw(selector string) []byte {
msg := q.get(selector)
if msg == nil {
return nil
}
b, _ := msg.MarshalJSON()
return b
}
//Strings returns a slice of strings at the given selector.
//If the value is a JSON array of strings, each element is returned.
//If the value is a single string, a one-element slice is returned.
//Returns nil if the selector doesn't exist or the value is not a string/array.
func (q *Query) Strings(selector string) []string {
raw := q.Raw(selector)
if raw == nil {
return nil
}
// Try array of strings first
var arr []json.RawMessage
if err := json.Unmarshal(raw, &arr); err == nil {
result := make([]string, 0, len(arr))
for _, item := range arr {
var s string
if err := json.Unmarshal(item, &s); err == nil && s != "" {
result = append(result, s)
}
}
if len(result) > 0 {
return result
}
return nil
}
// Try single string
var s string
if err := json.Unmarshal(raw, &s); err == nil && s != "" {
return []string{s}
}
return nil
}
//ArrayFieldStrings iterates the JSON array at selector and extracts the named
//field from each object element, returning the values as a string slice.
//Returns nil if the selector doesn't exist or the value is not an array.
func (q *Query) ArrayFieldStrings(selector string, field string) []string {
raw := q.Raw(selector)
if raw == nil {
return nil
}
var arr []json.RawMessage
if err := json.Unmarshal(raw, &arr); err != nil {
return nil
}
result := make([]string, 0, len(arr))
for _, item := range arr {
obj := New(string(item))
if s := obj.String(field); s != "" {
result = append(result, s)
}
}
if len(result) > 0 {
return result
}
return nil
}
func (q *Query) get(selector string) *json.RawMessage {
if selector == "" {
return nil
}
parts := strings.Split(selector, ".")
var result *json.RawMessage
var current map[string]*json.RawMessage
for _, part := range parts {
if part[len(part)-1:] == "]" {
idx, _ := strconv.Atoi(part[len(part)-2 : len(part)-1])
part = part[:len(part)-3]
if current[part] != nil {
result = current[part]
} else {
result = q.m[part]
}
if result != nil {
var arr []*json.RawMessage
bytes, _ := result.MarshalJSON()
err := json.Unmarshal(bytes, &arr)
if err != nil {
panic(err)
}
if len(arr) > idx {
bytes, _ = arr[idx].MarshalJSON()
err := json.Unmarshal(bytes, ¤t)
if err != nil {
return arr[idx]
}
}
}
} else {
if current[part] != nil {
result = current[part]
} else {
result = q.m[part]
}
if result != nil {
bytes, _ := result.MarshalJSON()
_ = json.Unmarshal(bytes, ¤t)
} else {
return nil
}
}
}
return result
}