Skip to content

armgit / fider

Public Imported from GitHub
0

Open platform to collect and prioritize feedback

Move JSON array extraction into jsonq package, simplify extractRolesFromJSON

Matt Roberts63b1baa9ddee
diff --git a/app/pkg/jsonq/jsonq.go b/app/pkg/jsonq/jsonq.go
index 942f04c82..7dfc36b04 100644
--- a/app/pkg/jsonq/jsonq.go
+++ b/app/pkg/jsonq/jsonq.go
@@ -96,6 +96,68 @@ func (q *Query) Raw(selector string) []byte {
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
diff --git a/app/pkg/jsonq/jsonq_test.go b/app/pkg/jsonq/jsonq_test.go
index 42ae1e40f..6b47c4c53 100644
--- a/app/pkg/jsonq/jsonq_test.go
+++ b/app/pkg/jsonq/jsonq_test.go
@@ -136,3 +136,66 @@ func TestContainsNested(t *testing.T) {
Expect(query.Contains("name")).IsFalse()
Expect(query.Contains("failures.what")).IsFalse()
}
+
+func TestStrings_ArrayOfStrings(t *testing.T) {
+ RegisterT(t)
+
+ query := jsonq.New(`{ "roles": ["ROLE_ADMIN", "ROLE_USER"] }`)
+ Expect(query.Strings("roles")).Equals([]string{"ROLE_ADMIN", "ROLE_USER"})
+}
+
+func TestStrings_SingleString(t *testing.T) {
+ RegisterT(t)
+
+ query := jsonq.New(`{ "role": "ROLE_ADMIN" }`)
+ Expect(query.Strings("role")).Equals([]string{"ROLE_ADMIN"})
+}
+
+func TestStrings_NestedPath(t *testing.T) {
+ RegisterT(t)
+
+ query := jsonq.New(`{ "user": { "profile": { "roles": ["ROLE_ADMIN"] } } }`)
+ Expect(query.Strings("user.profile.roles")).Equals([]string{"ROLE_ADMIN"})
+}
+
+func TestStrings_MissingSelectorReturnsNil(t *testing.T) {
+ RegisterT(t)
+
+ query := jsonq.New(`{ "name": "Jon" }`)
+ Expect(query.Strings("roles")).IsNil()
+}
+
+func TestStrings_EmptyArrayReturnsNil(t *testing.T) {
+ RegisterT(t)
+
+ query := jsonq.New(`{ "roles": [] }`)
+ Expect(query.Strings("roles")).IsNil()
+}
+
+func TestArrayFieldStrings_ExtractField(t *testing.T) {
+ RegisterT(t)
+
+ query := jsonq.New(`{ "roles": [{"id": "ROLE_ADMIN", "name": "Admin"}, {"id": "ROLE_USER", "name": "User"}] }`)
+ Expect(query.ArrayFieldStrings("roles", "id")).Equals([]string{"ROLE_ADMIN", "ROLE_USER"})
+}
+
+func TestArrayFieldStrings_NestedPath(t *testing.T) {
+ RegisterT(t)
+
+ query := jsonq.New(`{ "user": { "groups": [{"name": "ROLE_ADMIN"}, {"name": "ROLE_USER"}] } }`)
+ Expect(query.ArrayFieldStrings("user.groups", "name")).Equals([]string{"ROLE_ADMIN", "ROLE_USER"})
+}
+
+func TestArrayFieldStrings_MissingSelectorReturnsNil(t *testing.T) {
+ RegisterT(t)
+
+ query := jsonq.New(`{ "name": "Jon" }`)
+ Expect(query.ArrayFieldStrings("roles", "id")).IsNil()
+}
+
+func TestArrayFieldStrings_NotArrayReturnsNil(t *testing.T) {
+ RegisterT(t)
+
+ query := jsonq.New(`{ "roles": "not an array" }`)
+ Expect(query.ArrayFieldStrings("roles", "id")).IsNil()
+}
diff --git a/app/services/oauth/oauth.go b/app/services/oauth/oauth.go
index ecd16c345..b9e118f96 100644
--- a/app/services/oauth/oauth.go
+++ b/app/services/oauth/oauth.go
@@ -3,7 +3,7 @@ package oauth
import (
"context"
"encoding/base64"
- "encoding/json"
+
"fmt"
"net/url"
"strings"
@@ -201,85 +201,55 @@ func extractCompositeName(query *jsonq.Query, namePath string) string {
return ""
}
+// extractRolesFromJSON extracts role strings from a JSON body at the given path.
// Supports formats:
// - "roles" for array of strings: ["ROLE_ADMIN", "ROLE_USER"]
// - "roles[].id" for array of objects: [{"id": "ROLE_ADMIN"}, {"id": "ROLE_USER"}]
// - "user.roles[].name" for nested array of objects
+// - "role" for a single string or comma-separated value
func extractRolesFromJSON(jsonBody string, rolesPath string) []string {
rolesPath = strings.TrimSpace(rolesPath)
if rolesPath == "" {
return nil
}
- // Split "roles[].id" into actualPath="roles" and fieldToExtract="id"
- var fieldToExtract string
- var actualPath string
+ q := jsonq.New(jsonBody)
+
+ // "roles[].id" — array of objects, extract field from each
if strings.Contains(rolesPath, "[].") {
parts := strings.SplitN(rolesPath, "[].", 2)
- actualPath = parts[0]
- fieldToExtract = parts[1]
- } else {
- actualPath = rolesPath
+ return trimNonEmpty(q.ArrayFieldStrings(parts[0], parts[1]))
}
- // Use jsonq to navigate to the value at actualPath
- rawBytes := jsonq.New(jsonBody).Raw(actualPath)
- if rawBytes == nil {
+ // "roles" — array of strings or single (possibly comma-separated) string
+ values := q.Strings(rolesPath)
+ if len(values) == 0 {
return nil
}
- // Try to unmarshal as an array
- var arr []json.RawMessage
- if err := json.Unmarshal(rawBytes, &arr); err == nil {
- roles := make([]string, 0, len(arr))
- if fieldToExtract != "" {
- // Array of objects — extract the named field from each element
- for _, item := range arr {
- obj := jsonq.New(string(item))
- if s := strings.TrimSpace(obj.String(fieldToExtract)); s != "" {
- roles = append(roles, s)
- }
- }
- } else {
- // Array of plain strings
- for _, item := range arr {
- var s string
- if err := json.Unmarshal(item, &s); err == nil {
- if s = strings.TrimSpace(s); s != "" {
- roles = append(roles, s)
- }
- }
- }
- }
- if len(roles) > 0 {
- return roles
- }
- return nil
+ // Single string may contain comma-separated roles
+ if len(values) == 1 && strings.Contains(values[0], ",") {
+ values = strings.Split(values[0], ",")
}
- // Try to unmarshal as a plain string (comma-separated or single value)
- var str string
- if err := json.Unmarshal(rawBytes, &str); err == nil {
- str = strings.TrimSpace(str)
- if str == "" {
- return nil
- }
- var parts []string
- if strings.Contains(str, ",") {
- parts = strings.Split(str, ",")
- } else {
- parts = []string{str}
- }
- roles := make([]string, 0, len(parts))
- for _, r := range parts {
- if r = strings.TrimSpace(r); r != "" {
- roles = append(roles, r)
- }
+ return trimNonEmpty(values)
+}
+
+// trimNonEmpty trims whitespace from each string and returns only non-empty values.
+func trimNonEmpty(ss []string) []string {
+ if ss == nil {
+ return nil
+ }
+ result := make([]string, 0, len(ss))
+ for _, s := range ss {
+ if s = strings.TrimSpace(s); s != "" {
+ result = append(result, s)
}
- return roles
}
-
- return nil
+ if len(result) == 0 {
+ return nil
+ }
+ return result
}
func getOAuthAuthorizationURL(ctx context.Context, q *query.GetOAuthAuthorizationURL) error {