errors.go

package api

import (
	"encoding/json"

	"github.com/sourcegraph/sourcegraph/lib/errors"
)

// GraphQlErrors contains one or more GraphQlError instances.
type GraphQlErrors []*GraphQlError

// NewGraphQlErrors wraps raw GraphQL error payloads in GraphQlError values.
func NewGraphQlErrors(graphQLErrorPayloads []json.RawMessage) GraphQlErrors {
	errs := make(GraphQlErrors, 0, len(graphQLErrorPayloads))
	for _, graphQLErrorPayload := range graphQLErrorPayloads {
		var value any
		if err := json.Unmarshal(graphQLErrorPayload, &value); err != nil {
			value = map[string]any{"message": string(graphQLErrorPayload)}
		}
		errs = append(errs, &GraphQlError{v: value})
	}
	return errs
}

func (gg GraphQlErrors) Error() string {
	// This slightly convoluted implementation is used to ensure that output
	// remains stable with earlier versions of src-cli, which returned a wrapped
	// *multierror.Error when GraphQL errors were returned from the API.

	if len(gg) == 0 {
		// This shouldn't really happen, but let's handle it gracefully anyway.
		return ""
	}

	var errs errors.MultiError
	for _, err := range gg {
		errs = errors.Append(errs, err)
	}

	return errors.Wrap(errs, "GraphQL errors").Error()
}

// GraphQlError wraps a raw JSON error returned from a GraphQL endpoint.
type GraphQlError struct{ v any }

// Message returns the GraphQL error message, if one was set on the error.
func (g *GraphQlError) Message() (string, error) {
	e, ok := g.v.(map[string]any)
	if !ok {
		return "", errors.Errorf("unexpected GraphQL error of type %T", g.v)
	}

	if e["message"] == nil {
		return "", nil
	}
	message, ok := e["message"].(string)
	if !ok {
		return "", errors.Errorf("unexpected message of type %T", e["message"])
	}
	return message, nil
}

// Code returns the GraphQL error code, if one was set on the error.
func (g *GraphQlError) Code() (string, error) {
	ext, err := g.Extensions()
	if err != nil {
		return "", errors.Wrap(err, "getting error extensions")
	}

	if ext != nil {
		if ext["code"] == nil {
			return "", nil
		} else if code, ok := ext["code"].(string); ok {
			return code, nil
		}
		return "", errors.Errorf("unexpected code of type %T", ext["code"])
	}
	return "", nil
}

// Path returns the GraphQL error path, if one was set on the error.
func (g *GraphQlError) Path() ([]any, error) {
	e, ok := g.v.(map[string]any)
	if !ok {
		return nil, errors.Errorf("unexpected GraphQL error of type %T", g.v)
	}

	if e["path"] == nil {
		return nil, nil
	}
	path, ok := e["path"].([]any)
	if !ok {
		return nil, errors.Errorf("unexpected path of type %T", e["path"])
	}
	return path, nil
}

func (g *GraphQlError) Error() string {
	j, _ := json.MarshalIndent(g.v, "", "  ")
	return string(j)
}

// Extensions returns the GraphQL error extensions, if set, or nil if no
// extensions were set on the error.
func (g *GraphQlError) Extensions() (map[string]any, error) {
	e, ok := g.v.(map[string]any)
	if !ok {
		return nil, errors.Errorf("unexpected GraphQL error of type %T", g.v)
	}

	if e["extensions"] == nil {
		return nil, nil
	} else if me, ok := e["extensions"].(map[string]any); ok {
		return me, nil
	}
	return nil, errors.Errorf("unexpected extensions of type %T", e["extensions"])
}

var (
	_ error = &GraphQlError{}
	_ error = GraphQlErrors{}
)