refactor: GQL responses

internal/db/collection_update.go

@@ -259,15 +259,7 @@ func (c *collection) makeSelectionPlan(
 		txn,
 	)
 
-	return planner.MakePlan(&request.Request{
-		Queries: []*request.OperationDefinition{
-			{
-				Selections: []request.Selection{
-					slct,
-				},
-			},
-		},
-	})
+	return planner.MakeSelectionPlan(slct)
 }
 
 func (c *collection) makeSelectLocal(filter immutable.Option[request.Filter]) (*request.Select, error) {

internal/db/request.go

@@ -53,10 +53,10 @@ func (db *db) execRequest(ctx context.Context, request string) *client.RequestRe
 	results, err := planner.RunRequest(ctx, parsedRequest)
 	if err != nil {
 		res.GQL.Errors = []error{err}
-		return res
 	}
-
-	res.GQL.Data = results
+	if len(results) > 0 {
+		res.GQL.Data = results[0]
+	}
 	return res
 }
 

internal/db/subscriptions.go

@@ -70,7 +70,7 @@ func (db *db) handleSubscription(ctx context.Context, r *request.Request) (<-cha
 			p := planner.New(ctx, identity, db.acp, db, txn)
 			s := subRequest.ToSelect(evt.DocID, evt.Cid.String())
 
-			result, err := p.RunSubscriptionRequest(ctx, s)
+			result, err := p.RunSelection(ctx, s)
 			if err == nil && len(result) == 0 {
 				txn.Discard(ctx)
 				continue // Don't send anything back to the client if the request yields an empty dataset.

internal/planner/mapper/mapper.go

@@ -41,7 +41,75 @@ const (
 	CommitSelection
 )
 
-// ToSelect converts the given [parser.Select] into a [Select].
+// ToOperation converts the given [request.OperationDefinition] into an [Operation].
+//
+// In the process of doing so it will construct the document map required to access the data
+// yielded by the [Operation].
+func ToOperation(
+	ctx context.Context,
+	store client.Store,
+	operationRequest *request.OperationDefinition,
+) (*Operation, error) {
+	operation := &Operation{
+		DocumentMapping: core.NewDocumentMapping(),
+	}
+
+	for i, s := range operationRequest.Selections {
+		switch t := s.(type) {
+		case *request.CommitSelect:
+			s, err := toCommitSelect(ctx, store, t, i)
+			if err != nil {
+				return nil, err
+			}
+			renderKey := core.RenderKey{Index: i}
+			if t.Alias.HasValue() {
+				renderKey.Key = t.Alias.Value()
+			} else {
+				renderKey.Key = t.Name
+			}
+			operation.CommitSelects = append(operation.CommitSelects, s)
+			operation.DocumentMapping.Add(i, s.Name)
+			operation.DocumentMapping.SetChildAt(i, s.DocumentMapping)
+			operation.DocumentMapping.RenderKeys = append(operation.DocumentMapping.RenderKeys, renderKey)
+
+		case *request.Select:
+			s, err := toSelect(ctx, store, ObjectSelection, i, t, "")
+			if err != nil {
+				return nil, err
+			}
+			renderKey := core.RenderKey{Index: i}
+			if t.Alias.HasValue() {
+				renderKey.Key = t.Alias.Value()
+			} else {
+				renderKey.Key = t.Name
+			}
+			operation.Selects = append(operation.Selects, s)
+			operation.DocumentMapping.Add(i, s.Name)
+			operation.DocumentMapping.SetChildAt(i, s.DocumentMapping)
+			operation.DocumentMapping.RenderKeys = append(operation.DocumentMapping.RenderKeys, renderKey)
+
+		case *request.ObjectMutation:
+			m, err := toMutation(ctx, store, t, i)
+			if err != nil {
+				return nil, err
+			}
+			renderKey := core.RenderKey{Index: i}
+			if t.Alias.HasValue() {
+				renderKey.Key = t.Alias.Value()
+			} else {
+				renderKey.Key = t.Name
+			}
+			operation.Mutations = append(operation.Mutations, m)
+			operation.DocumentMapping.Add(i, m.Name)
+			operation.DocumentMapping.SetChildAt(i, m.DocumentMapping)
+			operation.DocumentMapping.RenderKeys = append(operation.DocumentMapping.RenderKeys, renderKey)
+		}
+	}
+
+	return operation, nil
+}
+
+// ToSelect converts the given [request.Select] into a [Select].
 //
 // In the process of doing so it will construct the document map required to access the data
 // yielded by the [Select].
@@ -1142,7 +1210,20 @@ func ToCommitSelect(
 	store client.Store,
 	selectRequest *request.CommitSelect,
 ) (*CommitSelect, error) {
-	underlyingSelect, err := ToSelect(ctx, store, CommitSelection, selectRequest.ToSelect())
+	return toCommitSelect(ctx, store, selectRequest, 0)
+}
+
+// toCommitSelect converts the given [request.CommitSelect] into a [CommitSelect].
+//
+// In the process of doing so it will construct the document map required to access the data
+// yielded by the [Select] embedded in the [CommitSelect].
+func toCommitSelect(
+	ctx context.Context,
+	store client.Store,
+	selectRequest *request.CommitSelect,
+	thisIndex int,
+) (*CommitSelect, error) {
+	underlyingSelect, err := toSelect(ctx, store, CommitSelection, thisIndex, selectRequest.ToSelect(), "")
 	if err != nil {
 		return nil, err
 	}
@@ -1160,11 +1241,23 @@ func ToCommitSelect(
 // In the process of doing so it will construct the document map required to access the data
 // yielded by the [Select] embedded in the [Mutation].
 func ToMutation(ctx context.Context, store client.Store, mutationRequest *request.ObjectMutation) (*Mutation, error) {
-	underlyingSelect, err := ToSelect(ctx, store, ObjectSelection, mutationRequest.ToSelect())
+	return toMutation(ctx, store, mutationRequest, 0)
+}
+
+// toMutation converts the given [request.Mutation] into a [Mutation].
+//
+// In the process of doing so it will construct the document map required to access the data
+// yielded by the [Select] embedded in the [Mutation].
+func toMutation(
+	ctx context.Context,
+	store client.Store,
+	mutationRequest *request.ObjectMutation,
+	thisIndex int,
+) (*Mutation, error) {
+	underlyingSelect, err := toSelect(ctx, store, ObjectSelection, thisIndex, mutationRequest.ToSelect(), "")
 	if err != nil {
 		return nil, err
 	}
-
 	return &Mutation{
 		Select:        *underlyingSelect,
 		Type:          MutationType(mutationRequest.Type),

internal/planner/mapper/operation.go

@@ -0,0 +1,31 @@
+// Copyright 2024 Democratized Data Foundation
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+package mapper
+
+import "github.com/sourcenetwork/defradb/internal/core"
+
+// Operation represents an operation such as query or mutation.
+//
+// It wraps child Selects belonging to this operation.
+type Operation struct {
+	// The document mapping for this select, describing how items yielded
+	// for this select can be accessed and rendered.
+	*core.DocumentMapping
+
+	// Selects is the list of selections in the operation.
+	Selects []*Select
+
+	// Mutations is the list of mutations in the operation.
+	Mutations []*Mutation
+
+	// CommitSelects is the list of commit selections in the operation.
+	CommitSelects []*CommitSelect
+}

internal/planner/operation.go

@@ -0,0 +1,178 @@
+// Copyright 2024 Democratized Data Foundation
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+package planner
+
+import (
+	"github.com/sourcenetwork/defradb/client/request"
+	"github.com/sourcenetwork/defradb/internal/core"
+	"github.com/sourcenetwork/defradb/internal/planner/mapper"
+)
+
+const operationNodeKind string = "operationNode"
+
+// operationNode is the top level node for operations with
+// one or more child selections, such as queries or mutations.
+type operationNode struct {
+	documentIterator
+	docMapper
+
+	children []planNode
+	isDone   bool
+}
+
+func (n *operationNode) Spans(spans core.Spans) {
+	for _, child := range n.children {
+		child.Spans(spans)
+	}
+}
+
+func (n *operationNode) Kind() string {
+	return operationNodeKind
+}
+
+func (n *operationNode) Init() error {
+	n.isDone = false
+	for _, child := range n.children {
+		err := child.Init()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (n *operationNode) Start() error {
+	for _, child := range n.children {
+		err := child.Start()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (n *operationNode) Close() error {
+	for _, child := range n.children {
+		err := child.Close()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (n *operationNode) Source() planNode {
+	return nil
+}
+
+func (p *operationNode) Children() []planNode {
+	return p.children
+}
+
+func (n *operationNode) Explain(explainType request.ExplainType) (map[string]any, error) {
+	switch explainType {
+	case request.SimpleExplain:
+		return map[string]any{}, nil
+
+	case request.ExecuteExplain:
+		return map[string]any{}, nil
+
+	default:
+		return nil, ErrUnknownExplainRequestType
+	}
+}
+
+func (n *operationNode) Next() (bool, error) {
+	if n.isDone {
+		return false, nil
+	}
+
+	n.currentValue = n.documentMapping.NewDoc()
+	for i, child := range n.children {
+		switch child.(type) {
+		case *topLevelNode:
+			hasChild, err := child.Next()
+			if err != nil {
+				return false, err
+			}
+			if !hasChild {
+				return false, ErrMissingChildValue
+			}
+			n.currentValue = child.Value()
+
+		default:
+			var docs []core.Doc
+			for {
+				hasChild, err := child.Next()
+				if err != nil {
+					return false, err
+				}
+				if !hasChild {
+					break
+				}
+				docs = append(docs, child.Value())
+			}
+			n.currentValue.Fields[i] = docs
+		}
+	}
+
+	n.isDone = true
+	return true, nil
+}
+
+// Operation creates a new operationNode using the given Selects.
+func (p *Planner) Operation(operation *mapper.Operation) (*operationNode, error) {
+	var children []planNode
+
+	for _, s := range operation.Selects {
+		if _, isAgg := request.Aggregates[s.Name]; isAgg {
+			// If this Select is an aggregate, then it must be a top-level
+			// aggregate and we need to resolve it within the context of a
+			// top-level node.
+			child, err := p.Top(s)
+			if err != nil {
+				return nil, err
+			}
+			children = append(children, child)
+		} else {
+			child, err := p.Select(s)
+			if err != nil {
+				return nil, err
+			}
+			children = append(children, child)
+		}
+	}
+
+	for _, m := range operation.Mutations {
+		child, err := p.newObjectMutationPlan(m)
+		if err != nil {
+			return nil, err
+		}
+		children = append(children, child)
+	}
+
+	for _, s := range operation.CommitSelects {
+		child, err := p.CommitSelect(s)
+		if err != nil {
+			return nil, err
+		}
+		children = append(children, child)
+	}
+
+	if len(children) == 0 {
+		return nil, ErrOperationDefinitionMissingSelection
+	}
+
+	return &operationNode{
+		docMapper: docMapper{operation.DocumentMapping},
+		children:  children,
+	}, nil
+}

internal/planner/operations.go

@@ -34,9 +34,11 @@ var (
 	_ planNode = (*valuesNode)(nil)
 	_ planNode = (*viewNode)(nil)
 	_ planNode = (*lensNode)(nil)
+	_ planNode = (*operationNode)(nil)
 
 	_ MultiNode = (*parallelNode)(nil)
 	_ MultiNode = (*topLevelNode)(nil)
+	_ MultiNode = (*operationNode)(nil)
 )
 
 // type joinNode struct {