fix: Make GraphQL errors spec compliant

cli/request.go

@@ -90,13 +90,9 @@ To learn more about the DefraDB GraphQL Query Language, refer to https://docs.so
 			store := mustGetContextStore(cmd)
 			result := store.ExecRequest(cmd.Context(), request, options...)
 
-			var errors []string
-			for _, err := range result.GQL.Errors {
-				errors = append(errors, err.Error())
-			}
 			if result.Subscription == nil {
 				cmd.Print(REQ_RESULTS_HEADER)
-				return writeJSON(cmd, map[string]any{"data": result.GQL.Data, "errors": errors})
+				return writeJSON(cmd, result.GQL)
 			}
 			cmd.Print(SUB_RESULTS_HEADER)
 			for item := range result.Subscription {

client/db.go

@@ -282,6 +282,12 @@ func WithVariables(variables map[string]any) RequestOption {
 	}
 }
 
+// GQLError represents an error that was encountered during a GQL request.
+type GQLError struct {
+	// Message contains a description of the error.
+	Message string `json:"message"`
+}
+
 // GQLResult represents the immediate results of a GQL request.
 //
 // It does not handle subscription channels. This object and its children are json serializable.
@@ -290,14 +296,33 @@ type GQLResult struct {
 	//
 	// If there are values in this slice the request will likely not have run to completion
 	// and [Data] will be nil.
-	Errors []error `json:"errors,omitempty"`
+	Errors []GQLError `json:"errors,omitempty"`
 
 	// Data contains the resultant data produced by the GQL request.
 	//
 	// It will be nil if any errors were raised during execution.
 	Data any `json:"data"`
 }
 
+// AddErrors appends a new GQLError to the result.
+func (res *GQLResult) AddErrors(errors ...error) {
+	for _, e := range errors {
+		res.Errors = append(res.Errors, GQLError{Message: e.Error()})
+	}
+}
+
+// GetErrors parses the list of GQLErrors into go errors.
+//
+// Any errors that match client specific errors will be revived
+// into their respective types.
+func (res *GQLResult) GetErrors() []error {
+	errors := make([]error, len(res.Errors))
+	for i, e := range res.Errors {
+		errors[i] = ReviveError(e.Message)
+	}
+	return errors
+}
+
 // RequestResult represents the results of a GQL request.
 type RequestResult struct {
 	// GQL contains the immediate results of the GQL request.

client/errors.go

@@ -13,6 +13,7 @@ package client
 import (
 	"fmt"
 
+	"github.com/sourcenetwork/defradb/datastore"
 	"github.com/sourcenetwork/defradb/errors"
 )
 
@@ -174,3 +175,17 @@ func NewErrFailedToParseKind(kind []byte) error {
 		errors.NewKV("Kind", kind),
 	)
 }
+
+// ReviveError attempts to return a client specific error from
+// the given message. If no matching error is found the message
+// is wrapped in a new anonymous error type.
+func ReviveError(message string) error {
+	switch message {
+	case ErrDocumentNotFoundOrNotAuthorized.Error():
+		return ErrDocumentNotFoundOrNotAuthorized
+	case datastore.ErrTxnConflict.Error():
+		return datastore.ErrTxnConflict
+	default:
+		return fmt.Errorf("%s", message)
+	}
+}

docs/website/references/http/openapi.json

@@ -341,7 +341,14 @@
                 "properties": {
                     "data": {},
                     "errors": {
-                        "items": {},
+                        "items": {
+                            "properties": {
+                                "message": {
+                                    "type": "string"
+                                }
+                            },
+                            "type": "object"
+                        },
                         "type": "array"
                     }
                 },

http/client.go

@@ -383,27 +383,27 @@
 
 	body, err := json.Marshal(gqlRequest)
 	if err != nil {
-		result.GQL.Errors = []error{err}
+		result.GQL.AddErrors(err)
 		return result
 	}
 
 	req, err := http.NewRequestWithContext(ctx, http.MethodPost, methodURL.String(), bytes.NewBuffer(body))
 	if err != nil {
-		result.GQL.Errors = []error{err}
+		result.GQL.AddErrors(err)
 		return result
 	}
 	err = c.http.setDefaultHeaders(req)
 
 	setDocEncryptionFlagIfNeeded(ctx, req)
 
 	if err != nil {
-		result.GQL.Errors = []error{err}
+		result.GQL.AddErrors(err)
 		return result
 	}
 
 	res, err := c.http.client.Do(req)
 	if err != nil {
-		result.GQL.Errors = []error{err}
+		result.GQL.AddErrors(err)
 		return result
 	}
 	if res.Header.Get("Content-Type") == "text/event-stream" {
@@ -417,16 +417,13 @@
 
 	data, err := io.ReadAll(res.Body)
 	if err != nil {
-		result.GQL.Errors = []error{err}
+		result.GQL.AddErrors(err)
 		return result
 	}
-	var response GraphQLResponse
-	if err = json.Unmarshal(data, &response); err != nil {
-		result.GQL.Errors = []error{err}
+	if err = json.Unmarshal(data, &result.GQL); err != nil {
+		result.GQL.AddErrors(err)
 		return result
 	}
-	result.GQL.Data = response.Data
-	result.GQL.Errors = response.Errors
 	return result
 }
 
@@ -447,14 +444,11 @@
 			if err != nil {
 				return
 			}
-			var response GraphQLResponse
-			if err := json.Unmarshal(evt.Data, &response); err != nil {
-				return
-			}
-			resCh <- client.GQLResult{
-				Errors: response.Errors,
-				Data:   response.Data,
+			var res client.GQLResult
+			if err := json.Unmarshal(evt.Data, &res); err != nil {
+				res.AddErrors(err)
 			}
+			resCh <- res
 		}
 	}()
 

http/errors.go

@@ -12,7 +12,9 @@
 
 import (
 	"encoding/json"
+	"fmt"
 
+	"github.com/sourcenetwork/defradb/client"
 	"github.com/sourcenetwork/defradb/errors"
 )
 
@@ -53,7 +55,11 @@
 	if err := json.Unmarshal(data, &out); err != nil {
 		return err
 	}
-	e.Error = parseError(out["error"])
+	if msg, ok := out["error"].(string); ok {
+		e.Error = client.ReviveError(msg)
+	} else {
+		e.Error = fmt.Errorf("%s", out)
+	}
 	return nil
 }
 

http/handler_store.go

@@ -11,7 +11,6 @@
 package http
 
 import (
-	"bytes"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -279,43 +278,6 @@ type GraphQLRequest struct {
 	Variables     map[string]any `json:"variables"`
 }
 
-type GraphQLResponse struct {
-	Data   any     `json:"data"`
-	Errors []error `json:"errors,omitempty"`
-}
-
-func (res GraphQLResponse) MarshalJSON() ([]byte, error) {
-	var errors []string
-	for _, err := range res.Errors {
-		errors = append(errors, err.Error())
-	}
-	return json.Marshal(map[string]any{"data": res.Data, "errors": errors})
-}
-
-func (res *GraphQLResponse) UnmarshalJSON(data []byte) error {
-	// decode numbers to json.Number
-	dec := json.NewDecoder(bytes.NewBuffer(data))
-	dec.UseNumber()
-
-	var out map[string]any
-	if err := dec.Decode(&out); err != nil {
-		return err
-	}
-	res.Data = out["data"]
-
-	// fix errors type to match tests
-	switch t := out["errors"].(type) {
-	case []any:
-		for _, v := range t {
-			res.Errors = append(res.Errors, parseError(v))
-		}
-	default:
-		res.Errors = nil
-	}
-
-	return nil
-}
-
 func (s *storeHandler) ExecRequest(rw http.ResponseWriter, req *http.Request) {
 	store := req.Context().Value(dbContextKey).(client.Store)
 
@@ -343,7 +305,7 @@ func (s *storeHandler) ExecRequest(rw http.ResponseWriter, req *http.Request) {
 	result := store.ExecRequest(req.Context(), request.Query, options...)
 
 	if result.Subscription == nil {
-		responseJSON(rw, http.StatusOK, GraphQLResponse{result.GQL.Data, result.GQL.Errors})
+		responseJSON(rw, http.StatusOK, result.GQL)
 		return
 	}
 	flusher, ok := rw.(http.Flusher)

http/openapi.go

@@ -26,7 +26,7 @@ var openApiSchemas = map[string]any{
 	"collection_delete":     &CollectionDeleteRequest{},
 	"peer_info":             &peer.AddrInfo{},
 	"graphql_request":       &GraphQLRequest{},
-	"graphql_response":      &GraphQLResponse{},
+	"graphql_response":      &client.GQLResult{},
 	"backup_config":         &client.BackupConfig{},
 	"collection":            &client.CollectionDescription{},
 	"schema":                &client.SchemaDescription{},

http/utils.go

@@ -12,12 +12,8 @@ package http
 
 import (
 	"encoding/json"
-	"fmt"
 	"io"
 	"net/http"
-
-	"github.com/sourcenetwork/defradb/client"
-	"github.com/sourcenetwork/defradb/datastore"
 )
 
 func requestJSON(req *http.Request, out any) error {
@@ -39,14 +35,3 @@ func responseJSON(rw http.ResponseWriter, status int, data any) {
 		log.ErrorE("failed to write response", err)
 	}
 }
-
-func parseError(msg any) error {
-	switch msg {
-	case client.ErrDocumentNotFoundOrNotAuthorized.Error():
-		return client.ErrDocumentNotFoundOrNotAuthorized
-	case datastore.ErrTxnConflict.Error():
-		return datastore.ErrTxnConflict
-	default:
-		return fmt.Errorf("%s", msg)
-	}
-}

internal/db/request.go

@@ -22,7 +22,7 @@
 	res := &client.RequestResult{}
 	ast, err := db.parser.BuildRequestAST(request)
 	if err != nil {
-		res.GQL.Errors = []error{err}
+		res.GQL.AddErrors(err)
 		return res
 	}
 	if db.parser.IsIntrospection(ast) {
@@ -31,13 +31,13 @@
 
 	parsedRequest, errors := db.parser.Parse(ast, options)
 	if len(errors) > 0 {
-		res.GQL.Errors = errors
+		res.GQL.AddErrors(errors...)
 		return res
 	}
 
 	pub, err := db.handleSubscription(ctx, parsedRequest)
 	if err != nil {
-		res.GQL.Errors = []error{err}
+		res.GQL.AddErrors(err)
 		return res
 	}
 
@@ -52,7 +52,7 @@
 
 	results, err := planner.RunRequest(ctx, parsedRequest)
 	if err != nil {
-		res.GQL.Errors = []error{err}
+		res.GQL.AddErrors(err)
 	}
 	res.GQL.Data = results
 	return res

internal/db/store.go

@@ -25,7 +25,7 @@
 	ctx, txn, err := ensureContextTxn(ctx, db, false)
 	if err != nil {
 		res := &client.RequestResult{}
-		res.GQL.Errors = []error{err}
+		res.GQL.AddErrors(err)
 		return res
 	}
 	defer txn.Discard(ctx)
@@ -41,7 +41,7 @@
 	}
 
 	if err := txn.Commit(ctx); err != nil {
-		res.GQL.Errors = []error{err}
+		res.GQL.AddErrors(err)
 		return res
 	}
 

internal/db/subscriptions.go

@@ -77,7 +77,7 @@ func (db *db) handleSubscription(ctx context.Context, r *request.Request) (<-cha
 			}
 			res := client.GQLResult{}
 			if err != nil {
-				res.Errors = []error{err}
+				res.AddErrors(err)
 			}
 			res.Data = result
 

internal/request/graphql/parser.go

@@ -72,13 +72,12 @@
 
 	res := &client.RequestResult{
 		GQL: client.GQLResult{
-			Data:   r.Data,
-			Errors: make([]error, len(r.Errors)),
+			Data: r.Data,
 		},
 	}
 
-	for i, err := range r.Errors {
-		res.GQL.Errors[i] = err
+	for _, err := range r.Errors {
+		res.GQL.AddErrors(err)
 	}
 
 	return res