Cypher AST Work and Cleanup

cypher/models/cypher/format/format.go

@@ -329,7 +329,7 @@ func (s Emitter) formatMapLiteral(output io.Writer, mapLiteral cypher.MapLiteral
 	}
 
 	first := true
-	for key, subExpression := range mapLiteral {
+	if err := mapLiteral.ForEachItem(func(key string, value cypher.Expression) error {
 		if !first {
 			if _, err := io.WriteString(output, ", "); err != nil {
 				return err
@@ -346,9 +346,13 @@ func (s Emitter) formatMapLiteral(output io.Writer, mapLiteral cypher.MapLiteral
 			return err
 		}
 
-		if err := s.WriteExpression(output, subExpression); err != nil {
+		if err := s.WriteExpression(output, value); err != nil {
 			return err
 		}
+
+		return nil
+	}); err != nil {
+		return err
 	}
 
 	if _, err := io.WriteString(output, "}"); err != nil {

cypher/models/cypher/format/format_test.go

@@ -2,6 +2,7 @@ package format_test
 
 import (
 	"bytes"
+	"errors"
 	"testing"
 
 	"github.com/specterops/dawgs/cypher/models/cypher"
@@ -27,6 +28,93 @@ func TestCypherEmitter_StripLiterals(t *testing.T) {
 	require.Equal(t, "match (n {value: $STRIPPED}) where n.other = $STRIPPED and n.number = $STRIPPED return n.name, n", buffer.String())
 }
 
+func TestCypherEmitter_FormatsMapLiteralInKeyOrder(t *testing.T) {
+	var (
+		buffer  = &bytes.Buffer{}
+		emitter = format.NewCypherEmitter(false)
+	)
+
+	err := emitter.WriteExpression(buffer, cypher.MapLiteral{
+		"b": cypher.NewLiteral(2, false),
+		"a": cypher.NewLiteral(1, false),
+	})
+
+	require.NoError(t, err)
+	require.Equal(t, "{a: 1, b: 2}", buffer.String())
+}
+
+func TestCypherEmitter_MapLiteralPropagatesExpressionError(t *testing.T) {
+	var (
+		buffer  = &bytes.Buffer{}
+		emitter = format.NewCypherEmitter(false)
+	)
+
+	err := emitter.WriteExpression(buffer, cypher.MapLiteral{
+		"bad": struct{}{},
+	})
+
+	require.ErrorContains(t, err, "unexpected expression type")
+}
+
+func TestCypherEmitter_MapLiteralPropagatesWriterError(t *testing.T) {
+	expectedErr := errors.New("write failed")
+	testCases := map[string]struct {
+		allowedWrites int
+		mapLiteral    cypher.MapLiteral
+	}{
+		"opening delimiter": {
+			allowedWrites: 0,
+			mapLiteral: cypher.MapLiteral{
+				"b": cypher.NewLiteral(2, false),
+			},
+		},
+		"key": {
+			allowedWrites: 1,
+			mapLiteral: cypher.MapLiteral{
+				"b": cypher.NewLiteral(2, false),
+			},
+		},
+		"colon": {
+			allowedWrites: 2,
+			mapLiteral: cypher.MapLiteral{
+				"b": cypher.NewLiteral(2, false),
+			},
+		},
+		"value": {
+			allowedWrites: 3,
+			mapLiteral: cypher.MapLiteral{
+				"b": cypher.NewLiteral(2, false),
+			},
+		},
+		"item separator": {
+			allowedWrites: 4,
+			mapLiteral: cypher.MapLiteral{
+				"a": cypher.NewLiteral(1, false),
+				"b": cypher.NewLiteral(2, false),
+			},
+		},
+		"closing delimiter": {
+			allowedWrites: 4,
+			mapLiteral: cypher.MapLiteral{
+				"b": cypher.NewLiteral(2, false),
+			},
+		},
+	}
+
+	for name, testCase := range testCases {
+		t.Run(name, func(t *testing.T) {
+			writer := &errorAfterNWrites{
+				remaining: testCase.allowedWrites,
+				err:       expectedErr,
+			}
+
+			err := format.NewCypherEmitter(false).WriteExpression(writer, testCase.mapLiteral)
+
+			require.ErrorIs(t, err, expectedErr)
+		})
+	}
+}
+
 func TestCypherEmitter_HappyPath(t *testing.T) {
 	test.LoadFixture(t, test.MutationTestCases).Run(t)
 	test.LoadFixture(t, test.PositiveTestCases).Run(t)
@@ -83,6 +171,20 @@ func TestNewStringLiteral_Escaping(t *testing.T) {
 	}
 }
 
+type errorAfterNWrites struct {
+	remaining int
+	err       error
+}
+
+func (s *errorAfterNWrites) Write(p []byte) (int, error) {
+	if s.remaining == 0 {
+		return 0, s.err
+	}
+
+	s.remaining--
+	return len(p), nil
+}
+
 func TestNewStringLiteral_InQuery(t *testing.T) {
 	// Test that escaped string literals work correctly in actual Cypher queries
 	testCases := []struct {

cypher/models/cypher/model.go

@@ -921,30 +921,49 @@ func (s MapLiteral) copy() MapLiteral {
 	return mapCopy
 }
 
+func (s MapLiteral) sortedKeys() []string {
+	keys := make([]string, 0, len(s))
+
+	for key := range s {
+		keys = append(keys, key)
+	}
+
+	sort.Strings(keys)
+	return keys
+}
+
 func (s MapLiteral) Items() []*MapItem {
 	items := make([]*MapItem, 0, len(s))
 
-	for key, value := range s {
+	_ = s.ForEachItem(func(key string, value Expression) error {
 		items = append(items, &MapItem{
 			Key:   key,
 			Value: value,
 		})
-	}
+		return nil
+	})
 
 	return items
 }
 
+func (s MapLiteral) ForEachItem(delegate func(key string, value Expression) error) error {
+	for _, key := range s.sortedKeys() {
+		if err := delegate(key, s[key]); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
 func (s MapLiteral) Keys() []any {
-	keys := make([]any, 0, len(s))
+	sortedKeys := s.sortedKeys()
+	keys := make([]any, len(sortedKeys))
 
-	for key := range s {
-		keys = append(keys, key)
+	for idx, key := range sortedKeys {
+		keys[idx] = key
 	}
 
-	sort.Slice(keys, func(i, j int) bool {
-		return strings.Compare(keys[i].(string), keys[j].(string)) > 0
-	})
-
 	return keys
 }
 

cypher/models/cypher/model_test.go

@@ -0,0 +1,74 @@
+package cypher_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/specterops/dawgs/cypher/models/cypher"
+	"github.com/stretchr/testify/require"
+)
+
+func TestMapLiteralItemsReturnsSortedItems(t *testing.T) {
+	aValue := cypher.NewVariableWithSymbol("a_value")
+	bValue := cypher.NewVariableWithSymbol("b_value")
+
+	items := cypher.MapLiteral{
+		"b": bValue,
+		"a": aValue,
+	}.Items()
+
+	require.Len(t, items, 2)
+	require.Equal(t, "a", items[0].Key)
+	require.Same(t, aValue, items[0].Value)
+	require.Equal(t, "b", items[1].Key)
+	require.Same(t, bValue, items[1].Value)
+}
+
+func TestMapLiteralForEachItemReturnsDelegateError(t *testing.T) {
+	expectedErr := errors.New("stop iteration")
+	var visitedKeys []string
+
+	err := cypher.MapLiteral{
+		"c": cypher.NewVariableWithSymbol("c_value"),
+		"b": cypher.NewVariableWithSymbol("b_value"),
+		"a": cypher.NewVariableWithSymbol("a_value"),
+	}.ForEachItem(func(key string, _ cypher.Expression) error {
+		visitedKeys = append(visitedKeys, key)
+		if key == "b" {
+			return expectedErr
+		}
+
+		return nil
+	})
+
+	require.ErrorIs(t, err, expectedErr)
+	require.Equal(t, []string{"a", "b"}, visitedKeys)
+}
+
+func TestMapLiteralKeysReturnsSortedKeys(t *testing.T) {
+	testCases := map[string]struct {
+		mapLiteral cypher.MapLiteral
+		expected   []any
+	}{
+		"nil": {
+			expected: []any{},
+		},
+		"empty": {
+			mapLiteral: cypher.MapLiteral{},
+			expected:   []any{},
+		},
+		"sorted": {
+			mapLiteral: cypher.MapLiteral{
+				"b": cypher.NewVariableWithSymbol("b_value"),
+				"a": cypher.NewVariableWithSymbol("a_value"),
+			},
+			expected: []any{"a", "b"},
+		},
+	}
+
+	for name, testCase := range testCases {
+		t.Run(name, func(t *testing.T) {
+			require.Equal(t, testCase.expected, testCase.mapLiteral.Keys())
+		})
+	}
+}

cypher/models/pgsql/translate/predicate_test.go

@@ -79,6 +79,12 @@ func translatePredicateQuery(t *testing.T, cypherQuery string, parameters map[st
 	return formatted
 }
 
+func TestExclusiveDisjunctionTranslates(t *testing.T) {
+	formatted := translatePredicateQuery(t, `MATCH (n:NodeKind1) WHERE true XOR false RETURN n`, nil)
+
+	require.Contains(t, formatted, "true != false")
+}
+
 func TestDynamicStringPredicatesUseHelperFunctions(t *testing.T) {
 	for _, testCase := range []struct {
 		name       string

cypher/models/pgsql/translate/references_test.go

@@ -48,6 +48,13 @@ func TestCollectReferencedIdentifiersIncludesPatternPredicateReferences(t *testi
 	require.True(t, referencedIdentifiers.Contains("r"))
 }
 
+func TestCollectReferencedIdentifiersIncludesExclusiveDisjunctionOperands(t *testing.T) {
+	referencedIdentifiers := referencedIdentifiersForQuery(t, "match (n), (m) where n.enabled = true xor m.enabled = true return n")
+
+	require.True(t, referencedIdentifiers.Contains("n"))
+	require.True(t, referencedIdentifiers.Contains("m"))
+}
+
 func TestCollectReferencedIdentifiersIncludesRepeatedMatchPatternDeclarations(t *testing.T) {
 	referencedIdentifiers := referencedIdentifiersForQuery(t, "match (a)-->(b) match (b)-->(c) return c")
 

cypher/models/pgsql/translate/translator.go

@@ -298,6 +298,11 @@ func (s *Translator) Enter(expression cypher.SyntaxNode) {
 			s.treeTranslator.VisitOperator(pgsql.OperatorOr)
 		}
 
+	case *cypher.ExclusiveDisjunction:
+		for idx := 0; idx < typedExpression.Len()-1; idx++ {
+			s.treeTranslator.VisitOperator(pgsql.OperatorNotEquals)
+		}
+
 	case *cypher.Conjunction:
 		for idx := 0; idx < typedExpression.Len()-1; idx++ {
 			s.treeTranslator.VisitOperator(pgsql.OperatorAnd)
@@ -559,6 +564,13 @@ func (s *Translator) Exit(expression cypher.SyntaxNode) {
 			}
 		}
 
+	case *cypher.ExclusiveDisjunction:
+		for idx := 0; idx < typedExpression.Len()-1; idx++ {
+			if err := s.treeTranslator.CompleteBinaryExpression(s.scope, pgsql.OperatorNotEquals); err != nil {
+				s.SetError(err)
+			}
+		}
+
 	case *cypher.Conjunction:
 		for idx := 0; idx < typedExpression.Len()-1; idx++ {
 			if err := s.treeTranslator.CompleteBinaryExpression(s.scope, pgsql.OperatorAnd); err != nil {