feat: allow null flagSetId Selector, restrict Selector to single key-value-pairs (#1708) (#1811)

## This PR
 
This pull request updates the `Selector` logic in the flag store to
allow selecting flags without a flagSetId (`flagSetId=`).

It also restricts selector expressions to a single key-value pair, and
updates / skips related tests. This is a temporary limitation pending a
decision on the selector syntax (#1708).

### Related Issues
<!-- add here the GitHub issue that this PR resolves if applicable -->

#1708


### Follow-up Tasks
TODO: we should decide on the selector syntax

### How to test

* run `make run-flagd-selector-demo`
* experiment with queries & flag configurations with/without flagSetIds
(be aware that the top level flagSetId is setting the flagSetId for all
flags without already exisiting flagSetId):
```
grpcurl -d '{"selector":"flagSetId=example"}' -import-path schemas/protobuf/flagd/sync/v1/ -proto sync.proto -plaintext localhost:8015 flagd.sync.v1.FlagSyncService/SyncFlags | jq
grpcurl -d '{"selector":"flagSetId="}' -import-path schemas/protobuf/flagd/sync/v1/ -proto sync.proto -plaintext localhost:8015 flagd.sync.v1.FlagSyncService/SyncFlags | jq
```

Signed-off-by: Alexandra Oberaigner <[email protected]>

Author: alexandraoberaigner

core/pkg/store/query.go

@@ -27,14 +27,15 @@ const flagSetIdKeySourceCompoundIndex = flagSetIdIndex + "+" + keyIndex + "+" +
 // any flag without a "flagSetId" is assigned this one; it's never exposed externally
 var nilFlagSetId = uuid.New().String()
 
-// A selector represents a set of constraints used to query the store.
+// A Selector represents a set of constraints used to query the store.
 type Selector struct {
 	indexMap map[string]string
 }
 
 // NewSelector creates a new Selector from a selector expression string.
-// For example, to select flags from source "./mySource" and flagSetId "1234", use the expression:
-// "source=./mySource,flagSetId=1234"
+// #1708 Until we decide on the Selector syntax, only a single key=value pair is supported
+// For example, to select flags from source "./mySource" or flagSetId "1234", use the expressions:
+// "source=./mySource" or "flagSetId=1234"
 func NewSelector(selectorExpression string) Selector {
 	return Selector{
 		indexMap: expressionToMap(selectorExpression),
@@ -47,27 +48,28 @@ func expressionToMap(sExp string) map[string]string {
 		return selectorMap
 	}
 
-	if strings.Index(sExp, "=") == -1 {
-		// if no '=' is found, treat the whole string as as source (backwards compatibility)
-		// we may may support interpreting this as a flagSetId in the future as an option
+	delimiterIdx := strings.Index(sExp, "=")
+	if delimiterIdx == -1 {
+		// if no '=' is found, treat the whole string as source (backwards compatibility)
+		// we may support interpreting this as a flagSetId in the future as an option
 		selectorMap[sourceIndex] = sExp
 		return selectorMap
 	}
 
-	// Split the selector by commas
-	pairs := strings.Split(sExp, ",")
-	for _, pair := range pairs {
-		// Split each pair by the first equal sign
-		parts := strings.Split(pair, "=")
-		if len(parts) == 2 {
-			key := parts[0]
-			value := parts[1]
-			selectorMap[key] = value
-		}
+	// split the selector by the first equal sign
+	key := sExp[:delimiterIdx]
+	value := sExp[delimiterIdx+1:]
+
+	// handle empty flagSetId as nilFlagSetId to query all flags without flagSetId
+	if key == "flagSetId" && value == "" {
+		value = nilFlagSetId
 	}
+	selectorMap[key] = value
+
 	return selectorMap
 }
 
+// WithIndex creates a new Selector from the current Selector and adds the given key-value-pair
 func (s Selector) WithIndex(key string, value string) Selector {
 	m := maps.Clone(s.indexMap)
 	m[key] = value
@@ -80,7 +82,7 @@ func (s *Selector) IsEmpty() bool {
 	return s == nil || len(s.indexMap) == 0
 }
 
-// SelectorMapToQuery converts the selector map to an indexId and constraints for querying the store.
+// ToQuery converts the Selector map to an indexId and constraints for querying the Store.
 // For a given index, a specific order and number of constraints are required.
 // Both the indexId and constraints are generated based on the keys present in the selector's internal map.
 func (s Selector) ToQuery() (indexId string, constraints []interface{}) {
@@ -114,7 +116,7 @@ func (s Selector) ToQuery() (indexId string, constraints []interface{}) {
 	return indexId, constraints
 }
 
-// SelectorToMetadata converts the selector's internal map to metadata for logging or tracing purposes.
+// ToMetadata converts the selector's internal map to metadata for logging or tracing purposes.
 // Only includes known indices to avoid leaking sensitive information, and is usually returned as the "top level" metadata
 func (s *Selector) ToMetadata() model.Metadata {
 	meta := model.Metadata{}

core/pkg/store/query_test.go

@@ -33,6 +33,11 @@ func TestSelector_IsEmpty(t *testing.T) {
 			selector:  &Selector{indexMap: map[string]string{"source": "abc"}},
 			wantEmpty: false,
 		},
+		{
+			name:      "non-empty indexMap, empty value",
+			selector:  &Selector{indexMap: map[string]string{"flagSetId": ""}},
+			wantEmpty: false,
+		},
 	}
 
 	for _, tt := range tests {
@@ -68,24 +73,33 @@ func TestSelector_ToQuery(t *testing.T) {
 		wantIndex  string
 		wantConstr []interface{}
 	}{
-		{
-			name:       "flagSetId and key primary index special case",
-			selector:   Selector{indexMap: map[string]string{"flagSetId": "fsid", "key": "myKey"}},
-			wantIndex:  "id",
-			wantConstr: []interface{}{"fsid", "myKey"},
-		},
-		{
-			name:       "multiple keys sorted",
-			selector:   Selector{indexMap: map[string]string{"source": "src", "flagSetId": "fsid"}},
-			wantIndex:  "flagSetId+source",
-			wantConstr: []interface{}{"fsid", "src"},
-		},
+		// #1708 Until we decide on the Selector syntax, only a single key=value pair is supported
+		/*
+			{
+				name:       "flagSetId and key primary index special case",
+				selector:   Selector{indexMap: map[string]string{"flagSetId": "fsid", "key": "myKey"}},
+				wantIndex:  "id",
+				wantConstr: []interface{}{"fsid", "myKey"},
+			},
+			{
+				name:       "multiple keys sorted",
+				selector:   Selector{indexMap: map[string]string{"source": "src", "flagSetId": "fsid"}},
+				wantIndex:  "flagSetId+source",
+				wantConstr: []interface{}{"fsid", "src"},
+			},
+		*/
 		{
 			name:       "single key",
 			selector:   Selector{indexMap: map[string]string{"source": "src"}},
 			wantIndex:  "source",
 			wantConstr: []interface{}{"src"},
 		},
+		{
+			name:       "flagSetId null",
+			selector:   Selector{indexMap: map[string]string{"flagSetId": ""}},
+			wantIndex:  "flagSetId",
+			wantConstr: []interface{}{""},
+		},
 	}
 
 	for _, tt := range tests {
@@ -132,16 +146,19 @@ func TestSelector_ToMetadata(t *testing.T) {
 			selector: &Selector{indexMap: map[string]string{"source": "src"}},
 			want:     model.Metadata{"source": "src"},
 		},
-		{
-			name:     "flagSetId and source",
-			selector: &Selector{indexMap: map[string]string{"flagSetId": "fsid", "source": "src"}},
-			want:     model.Metadata{"flagSetId": "fsid", "source": "src"},
-		},
-		{
-			name:     "flagSetId, source, and key (key should be ignored)",
-			selector: &Selector{indexMap: map[string]string{"flagSetId": "fsid", "source": "src", "key": "myKey"}},
-			want:     model.Metadata{"flagSetId": "fsid", "source": "src"},
-		},
+		// #1708 Until we decide on the Selector syntax, only a single key=value pair is supported
+		/*
+			{
+				name:     "flagSetId and source",
+				selector: &Selector{indexMap: map[string]string{"flagSetId": "fsid", "source": "src"}},
+				want:     model.Metadata{"flagSetId": "fsid", "source": "src"},
+			},
+			{
+				name:     "flagSetId, source, and key (key should be ignored)",
+				selector: &Selector{indexMap: map[string]string{"flagSetId": "fsid", "source": "src", "key": "myKey"}},
+				want:     model.Metadata{"flagSetId": "fsid", "source": "src"},
+			},
+		*/
 	}
 
 	for _, tt := range tests {
@@ -160,11 +177,14 @@ func TestNewSelector(t *testing.T) {
 		input   string
 		wantMap map[string]string
 	}{
-		{
-			name:    "source and flagSetId",
-			input:   "source=abc,flagSetId=1234",
-			wantMap: map[string]string{"source": "abc", "flagSetId": "1234"},
-		},
+		// #1708 Until we decide on the Selector syntax, only a single key=value pair is supported
+		/*
+			{
+				name:    "source and flagSetId",
+				input:   "source=abc,flagSetId=1234",
+				wantMap: map[string]string{"source": "abc", "flagSetId": "1234"},
+			},
+		*/
 		{
 			name:    "source",
 			input:   "source=abc",
@@ -175,6 +195,11 @@ func TestNewSelector(t *testing.T) {
 			input:   "mysource",
 			wantMap: map[string]string{"source": "mysource"},
 		},
+		{
+			name:    "null flagSetId",
+			input:   "flagSetId=",
+			wantMap: map[string]string{"flagSetId": nilFlagSetId},
+		},
 		{
 			name:    "empty string",
 			input:   "",

core/pkg/store/store_test.go

@@ -379,7 +379,8 @@ func TestGetAllNoWatcher(t *testing.T) {
 
 	sourceASelector := NewSelector("source=" + sourceA.Name)
 	flagSetIdCSelector := NewSelector("flagSetId=" + flagSetIdC)
-	flagSetIdAndCSelector := NewSelector("flagSetId=" + flagSetIdC + ",source=" + sourceC.Name)
+	// #1708 Until we decide on the Selector syntax, only a single key=value pair is supported
+	//flagSetIdAndCSelector := NewSelector("flagSetId=" + flagSetIdC + ",source=" + sourceC.Name)
 
 	t.Parallel()
 	tests := []struct {
@@ -420,14 +421,17 @@ func TestGetAllNoWatcher(t *testing.T) {
 				{Key: "dupe", DefaultVariant: "off", Source: sourceC.Name, FlagSetId: flagSetIdC, Priority: 2, Metadata: model.Metadata{"flagSetId": flagSetIdC}},
 			},
 		},
-		{
-			name:     "flagSetId and source selector",
-			selector: &flagSetIdAndCSelector,
-			wantFlags: []model.Flag{
-				{Key: "dupeMultiSource", DefaultVariant: "both", Source: sourceC.Name, FlagSetId: flagSetIdC, Metadata: model.Metadata{"flagSetId": flagSetIdC}, Priority: 2},
-				{Key: "dupe", DefaultVariant: "off", Source: sourceC.Name, FlagSetId: flagSetIdC, Priority: 2, Metadata: model.Metadata{"flagSetId": flagSetIdC}},
+		// #1708 Until we decide on the Selector syntax, only a single key=value pair is supported
+		/*
+			{
+				name:     "flagSetId and source selector",
+				selector: &flagSetIdAndCSelector,
+				wantFlags: []model.Flag{
+					{Key: "dupeMultiSource", DefaultVariant: "both", Source: sourceC.Name, FlagSetId: flagSetIdC, Metadata: model.Metadata{"flagSetId": flagSetIdC}, Priority: 2},
+					{Key: "dupe", DefaultVariant: "off", Source: sourceC.Name, FlagSetId: flagSetIdC, Priority: 2, Metadata: model.Metadata{"flagSetId": flagSetIdC}},
+				},
 			},
-		},
+		*/
 	}
 
 	sourceOrder := []struct {
@@ -633,11 +637,18 @@ func TestQueryMetadata(t *testing.T) {
 	// setup initial flags
 	store.Update(sourceA, sourceAFlags, model.Metadata{})
 
-	selector := NewSelector("source=" + otherSource + ",flagSetId=" + nonExistingFlagSetId)
+	// #1708 Until we decide on the Selector syntax, only a single key=value pair is supported
+	// 		 these tests should then also cover more complex selectors
+
+	selector := NewSelector("flagSetId=" + nonExistingFlagSetId)
 	_, metadata, _ := store.GetAll(context.Background(), &selector)
-	assert.Equal(t, metadata, model.Metadata{"source": otherSource, "flagSetId": nonExistingFlagSetId}, "metadata did not match expected")
+	assert.Equal(t, metadata, model.Metadata{"flagSetId": nonExistingFlagSetId}, "metadata did not match expected")
+
+	selector = NewSelector("flagSetId=" + nonExistingFlagSetId)
+	_, metadata, _ = store.Get(context.Background(), "key", &selector)
+	assert.Equal(t, metadata, model.Metadata{"flagSetId": nonExistingFlagSetId}, "metadata did not match expected")
 
-	selector = NewSelector("source=" + otherSource + ",flagSetId=" + nonExistingFlagSetId)
+	selector = NewSelector("source=" + otherSource)
 	_, metadata, _ = store.Get(context.Background(), "key", &selector)
-	assert.Equal(t, metadata, model.Metadata{"source": otherSource, "flagSetId": nonExistingFlagSetId}, "metadata did not match expected")
+	assert.Equal(t, metadata, model.Metadata{"source": otherSource}, "metadata did not match expected")
 }