fix: validate v2 sort and split creates

Author: zinic

query/v2/query.go

@@ -385,10 +385,24 @@ func Desc(expression any) *cypher.SortItem {
 	return Order(expression, SortDescending)
 }
 
+func validateSortDirection(direction SortDirection) error {
+	switch direction {
+	case SortAscending, SortDescending:
+		return nil
+	default:
+		return fmt.Errorf("unsupported sort direction: %d", direction)
+	}
+}
+
 func Order(expression any, direction SortDirection) *cypher.SortItem {
+	expressionValue := expressionOrError(expression)
+	if err := validateSortDirection(direction); err != nil {
+		expressionValue = invalidExpression(err)
+	}
+
 	return &cypher.SortItem{
 		Ascending:  direction != SortDescending,
-		Expression: expressionOrError(expression),
+		Expression: expressionValue,
 	}
 }
 
@@ -1097,25 +1111,57 @@ func isCreateNodeValue(value any, identifiers runtimeIdentifiers) bool {
 	return false
 }
 
+func isCreateRelationshipValue(value any) bool {
+	_, typeOK := value.(*cypher.RelationshipPattern)
+	return typeOK
+}
+
 func nextCreateValueIsNode(creates []any, idx int, identifiers runtimeIdentifiers) bool {
 	nextIdx := idx + 1
 	return nextIdx < len(creates) && isCreateNodeValue(creates[nextIdx], identifiers)
 }
 
+func newCreatePatternPart(createClause *cypher.Create) *cypher.PatternPart {
+	pattern := &cypher.PatternPart{}
+	createClause.Pattern = append(createClause.Pattern, pattern)
+	return pattern
+}
+
+func createPatternHasElements(pattern *cypher.PatternPart) bool {
+	return pattern != nil && len(pattern.PatternElements) > 0
+}
+
+func shouldStartNewCreatePattern(pattern *cypher.PatternPart, nextCreate any, patternClosed bool, identifiers runtimeIdentifiers) bool {
+	if !createPatternHasElements(pattern) {
+		return false
+	}
+
+	if isCreateNodeValue(nextCreate, identifiers) && patternEndsWithNodePattern(pattern) {
+		return true
+	}
+
+	return patternClosed && isCreateRelationshipValue(nextCreate)
+}
+
 func buildCreates(singlePartQuery *cypher.SinglePartQuery, identifiers runtimeIdentifiers, creates []any) error {
 	if len(creates) == 0 {
 		return nil
 	}
 
 	var (
-		pattern      = &cypher.PatternPart{}
 		createClause = &cypher.Create{
-			Unique:  false,
-			Pattern: []*cypher.PatternPart{pattern},
+			Unique: false,
 		}
+		pattern       = newCreatePatternPart(createClause)
+		patternClosed bool
 	)
 
 	for idx, nextCreate := range creates {
+		if shouldStartNewCreatePattern(pattern, nextCreate, patternClosed, identifiers) {
+			pattern = newCreatePatternPart(createClause)
+			patternClosed = false
+		}
+
 		switch typedNextCreate := nextCreate.(type) {
 		case QualifiedExpression:
 			switch typedExpression := typedNextCreate.qualifier().(type) {
@@ -1129,6 +1175,7 @@ func buildCreates(singlePartQuery *cypher.SinglePartQuery, identifiers runtimeId
 					pattern.AddPatternElements(&cypher.NodePattern{
 						Variable: cypher.NewVariableWithSymbol(typedExpression.Symbol),
 					})
+					patternClosed = false
 
 				default:
 					return fmt.Errorf("invalid variable reference for create: %s", typedExpression.Symbol)
@@ -1144,6 +1191,7 @@ func buildCreates(singlePartQuery *cypher.SinglePartQuery, identifiers runtimeId
 			}
 
 			pattern.AddPatternElements(cypher.Copy(typedNextCreate))
+			patternClosed = false
 
 		case *cypher.RelationshipPattern:
 			if err := validateRelationshipPattern(typedNextCreate); err != nil {
@@ -1162,6 +1210,9 @@ func buildCreates(singlePartQuery *cypher.SinglePartQuery, identifiers runtimeId
 				pattern.AddPatternElements(&cypher.NodePattern{
 					Variable: identifiers.End(),
 				})
+				patternClosed = true
+			} else {
+				patternClosed = false
 			}
 
 		default:

query/v2/query_test.go

@@ -19,6 +19,21 @@ func renderPrepared(t *testing.T, preparedQuery *v2.PreparedQuery) string {
 	return cypherQueryStr
 }
 
+func firstCreateClause(t *testing.T, preparedQuery *v2.PreparedQuery) *cypher.Create {
+	t.Helper()
+
+	updatingClauses := preparedQuery.Query.SingleQuery.SinglePartQuery.UpdatingClauses
+	require.NotEmpty(t, updatingClauses)
+
+	updatingClause, typeOK := updatingClauses[0].(*cypher.UpdatingClause)
+	require.True(t, typeOK)
+
+	createClause, typeOK := updatingClause.Clause.(*cypher.Create)
+	require.True(t, typeOK)
+
+	return createClause
+}
+
 func TestQuery(t *testing.T) {
 	preparedQuery, err := v2.New().Where(
 		v2.Not(v2.Relationship().Kind().Is(graph.StringKind("test"))),
@@ -102,6 +117,28 @@ func TestCreateRelationshipWithExplicitEndpoints(t *testing.T) {
 	}, preparedQuery.Parameters)
 }
 
+func TestCreateSplitsDisjointNodePatterns(t *testing.T) {
+	preparedQuery, err := v2.New().Create(
+		v2.NodePattern(graph.Kinds{graph.StringKind("A")}, nil),
+		v2.NodePattern(graph.Kinds{graph.StringKind("B")}, nil),
+	).Build()
+	require.NoError(t, err)
+
+	require.Equal(t, "create (n:A), (n:B)", renderPrepared(t, preparedQuery))
+	require.Len(t, firstCreateClause(t, preparedQuery).Pattern, 2)
+}
+
+func TestCreateSplitsBackToBackRelationshipPatterns(t *testing.T) {
+	preparedQuery, err := v2.New().Create(
+		v2.RelationshipPattern(graph.StringKind("A"), nil, graph.DirectionOutbound),
+		v2.RelationshipPattern(graph.StringKind("B"), nil, graph.DirectionOutbound),
+	).Build()
+	require.NoError(t, err)
+
+	require.Equal(t, "create (s)-[r:A]->(e), (s)-[r:B]->(e)", renderPrepared(t, preparedQuery))
+	require.Len(t, firstCreateClause(t, preparedQuery).Pattern, 2)
+}
+
 func TestCreateNodeReturnDoesNotCreateMatch(t *testing.T) {
 	preparedQuery, err := v2.New().Create(
 		v2.Node().NodePattern(graph.Kinds{graph.StringKind("A")}, v2.NamedParameter("props", map[string]any{"name": "node"})),
@@ -532,6 +569,13 @@ func TestProjectionAndOrderHelpers(t *testing.T) {
 	require.Equal(t, "match (n) return distinct id(n) as node_id order by n.name asc, id(n) desc", renderPrepared(t, preparedQuery))
 }
 
+func TestInvalidSortDirectionReturnsError(t *testing.T) {
+	_, err := v2.New().Return(v2.Node()).OrderBy(
+		v2.Order(v2.Node().Property("name"), v2.SortDirection(99)),
+	).Build()
+	require.ErrorContains(t, err, "unsupported sort direction: 99")
+}
+
 func TestPaginationZeroValuesAndNegativeValidation(t *testing.T) {
 	preparedQuery, err := v2.New().Return(v2.Node()).Skip(0).Limit(0).Build()
 	require.NoError(t, err)