From 17ab8ffdbf911c701f982c411a9fd0a7750f6572 Mon Sep 17 00:00:00 2001 From: Andrew Sisley Date: Mon, 16 Jan 2023 14:56:27 -0500 Subject: [PATCH] Extract parser errors to dedicated file --- query/graphql/parser/errors.go | 23 +++++++++++++++++++++++ query/graphql/parser/filter.go | 16 ++++++++-------- query/graphql/parser/mutation.go | 12 ++++-------- query/graphql/parser/query.go | 18 +++++++++--------- query/graphql/parser/subscription.go | 3 +-- 5 files changed, 45 insertions(+), 27 deletions(-) create mode 100644 query/graphql/parser/errors.go diff --git a/query/graphql/parser/errors.go b/query/graphql/parser/errors.go new file mode 100644 index 0000000000..ad697de167 --- /dev/null +++ b/query/graphql/parser/errors.go @@ -0,0 +1,23 @@ +// Copyright 2022 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 parser + +import "github.com/sourcenetwork/defradb/errors" + +var ( + ErrFilterMissingArgumentType = errors.New("couldn't find filter argument type") + ErrInvalidOrderDirection = errors.New("invalid order direction string") + ErrFailedToParseConditionsFromAST = errors.New("couldn't parse conditions value from AST") + ErrFailedToParseConditionValue = errors.New("failed to parse condition value from query filter statement") + ErrEmptyDataPayload = errors.New("given data payload is empty") + ErrUnknownMutationName = errors.New("unknown mutation name") + ErrUnknownGQLOperation = errors.New("unknown GraphQL operation type") +) diff --git a/query/graphql/parser/filter.go b/query/graphql/parser/filter.go index 9b421de203..7afb626372 100644 --- a/query/graphql/parser/filter.go +++ b/query/graphql/parser/filter.go @@ -20,8 +20,8 @@ import ( gqls "github.com/graphql-go/graphql/language/source" "github.com/sourcenetwork/immutable" + "github.com/sourcenetwork/defradb/client" "github.com/sourcenetwork/defradb/client/request" - "github.com/sourcenetwork/defradb/errors" ) // type condition @@ -60,7 +60,7 @@ func NewFilterFromString( parentFieldType := gql.GetFieldDef(schema, schema.QueryType(), collectionType) filterType, ok := getArgumentType(parentFieldType, request.FilterClause) if !ok { - return immutable.None[request.Filter](), errors.New("couldn't find filter argument type") + return immutable.None[request.Filter](), ErrFilterMissingArgumentType } return NewFilter(obj, filterType) } @@ -82,7 +82,7 @@ func ParseConditionsInOrder(stmt *ast.ObjectValue) ([]request.OrderCondition, er if v, ok := cond.([]request.OrderCondition); ok { return v, nil } - return nil, errors.New("failed to parse statement") + return nil, client.NewErrUnexpectedType[[]request.OrderCondition]("condition", cond) } func parseConditionsInOrder(stmt *ast.ObjectValue) (any, error) { @@ -101,7 +101,7 @@ func parseConditionsInOrder(stmt *ast.ObjectValue) (any, error) { case string: // base direction parsed (hopefully, check NameToOrderDirection) dir, ok := request.NameToOrderDirection[v] if !ok { - return nil, errors.New("invalid order direction string") + return nil, ErrInvalidOrderDirection } conditions = append(conditions, request.OrderCondition{ Fields: []string{name}, @@ -120,7 +120,7 @@ func parseConditionsInOrder(stmt *ast.ObjectValue) (any, error) { } default: - return nil, errors.New("unexpected parsed type for parseConditionInOrder") + return nil, client.NewErrUnhandledType("parseConditionInOrder", val) } } @@ -138,13 +138,13 @@ func ParseConditions(stmt *ast.ObjectValue, inputType gql.Input) (map[string]any if v, ok := cond.(map[string]any); ok { return v, nil } - return nil, errors.New("failed to parse statement") + return nil, client.NewErrUnexpectedType[map[string]any]("condition", cond) } func parseConditions(stmt *ast.ObjectValue, inputArg gql.Input) (any, error) { val := gql.ValueFromAST(stmt, inputArg, nil) if val == nil { - return nil, errors.New("couldn't parse conditions value from AST") + return nil, ErrFailedToParseConditionsFromAST } return val, nil } @@ -187,7 +187,7 @@ func parseVal(val ast.Value, recurseFn parseFn) (any, error) { return conditions, nil } - return nil, errors.New("failed to parse condition value from query filter statement") + return nil, ErrFailedToParseConditionValue } /* diff --git a/query/graphql/parser/mutation.go b/query/graphql/parser/mutation.go index 3db13e6cc9..5ce9205317 100644 --- a/query/graphql/parser/mutation.go +++ b/query/graphql/parser/mutation.go @@ -17,12 +17,8 @@ import ( "github.com/graphql-go/graphql/language/ast" "github.com/sourcenetwork/immutable" + "github.com/sourcenetwork/defradb/client" "github.com/sourcenetwork/defradb/client/request" - "github.com/sourcenetwork/defradb/errors" -) - -var ( - ErrEmptyDataPayload = errors.New("given data payload is empty") ) var ( @@ -89,7 +85,7 @@ func parseMutation(schema gql.Schema, parent *gql.Object, field *ast.Field) (*re var ok bool mut.Type, ok = mutationNameToType[typeStr] if !ok { - return nil, errors.New("unknown mutation name") + return nil, ErrUnknownMutationName } if len(mutNameParts) > 1 { // only generated object mutations @@ -115,7 +111,7 @@ func parseMutation(schema gql.Schema, parent *gql.Object, field *ast.Field) (*re obj := argument.Value.(*ast.ObjectValue) filterType, ok := getArgumentType(fieldDef, request.FilterClause) if !ok { - return nil, errors.New("couldn't get argument type for filter") + return nil, ErrFilterMissingArgumentType } filter, err := NewFilter(obj, filterType) if err != nil { @@ -132,7 +128,7 @@ func parseMutation(schema gql.Schema, parent *gql.Object, field *ast.Field) (*re for i, val := range raw.Values { id, ok := val.(*ast.StringValue) if !ok { - return nil, errors.New("ids argument has a non string value") + return nil, client.NewErrUnexpectedType[*ast.StringValue]("ids argument", val) } ids[i] = id.Value } diff --git a/query/graphql/parser/query.go b/query/graphql/parser/query.go index 78cbe4278e..a532fc7d9b 100644 --- a/query/graphql/parser/query.go +++ b/query/graphql/parser/query.go @@ -17,8 +17,8 @@ import ( "github.com/graphql-go/graphql/language/ast" "github.com/sourcenetwork/immutable" + "github.com/sourcenetwork/defradb/client" "github.com/sourcenetwork/defradb/client/request" - "github.com/sourcenetwork/defradb/errors" ) // ParseQuery parses a root ast.Document, and returns a @@ -26,7 +26,7 @@ import ( // Requires a non-nil doc, will error if given a nil doc. func ParseQuery(schema gql.Schema, doc *ast.Document) (*request.Request, []error) { if doc == nil { - return nil, []error{errors.New("parseQuery requires a non-nil ast.Document")} + return nil, []error{client.NewErrUninitializeProperty("parseQuery", "doc")} } r := &request.Request{ Queries: make([]*request.OperationDefinition, 0), @@ -60,7 +60,7 @@ func ParseQuery(schema gql.Schema, doc *ast.Document) (*request.Request, []error } r.Subscription = append(r.Subscription, sdef) default: - return nil, []error{errors.New("unknown GraphQL operation type")} + return nil, []error{ErrUnknownGQLOperation} } } } @@ -179,7 +179,7 @@ func parseSelect( obj := astValue.(*ast.ObjectValue) filterType, ok := getArgumentType(fieldDef, request.FilterClause) if !ok { - return nil, errors.New("couldn't get argument type for filter") + return nil, ErrFilterMissingArgumentType } filter, err := NewFilter(obj, filterType) if err != nil { @@ -341,19 +341,19 @@ func parseAggregate(schema gql.Schema, parent *gql.Object, field *ast.Field, ind fieldDef := gql.GetFieldDef(schema, parent, field.Name.Value) argType, ok := getArgumentType(fieldDef, hostName) if !ok { - return nil, errors.New("couldn't get argument type for filter") + return nil, ErrFilterMissingArgumentType } argTypeObject, ok := argType.(*gql.InputObject) if !ok { - return nil, errors.New("expected arg type to be object") + return nil, client.NewErrUnexpectedType[*gql.InputObject]("arg type", argType) } filterType, ok := getArgumentTypeFromInput(argTypeObject, request.FilterClause) if !ok { - return nil, errors.New("couldn't get argument type for filter") + return nil, ErrFilterMissingArgumentType } filterObjVal, ok := filterArg.Value.(*ast.ObjectValue) if !ok { - return nil, errors.New("couldn't get object value type for filter") + return nil, client.NewErrUnexpectedType[*gql.InputObject]("filter arg", filterArg.Value) } filterValue, err := NewFilter(filterObjVal, filterType) if err != nil { @@ -474,7 +474,7 @@ func typeFromFieldDef(field *gql.FieldDefinition) (*gql.Object, error) { case *gql.List: fieldObject = ftype.OfType.(*gql.Object) default: - return nil, errors.New("couldn't get field object from definition") + return nil, client.NewErrUnhandledType("field", field) } return fieldObject, nil } diff --git a/query/graphql/parser/subscription.go b/query/graphql/parser/subscription.go index 48637de551..d8b67f24e0 100644 --- a/query/graphql/parser/subscription.go +++ b/query/graphql/parser/subscription.go @@ -15,7 +15,6 @@ import ( "github.com/graphql-go/graphql/language/ast" "github.com/sourcenetwork/defradb/client/request" - "github.com/sourcenetwork/defradb/errors" ) // parseSubscriptionOperationDefinition parses the individual GraphQL @@ -64,7 +63,7 @@ func parseSubscription(schema gql.Schema, field *ast.Field) (*request.ObjectSubs if prop == request.FilterClause { filterType, ok := getArgumentType(fieldDef, request.FilterClause) if !ok { - return nil, errors.New("couldn't get argument type for subscription filter") + return nil, ErrFilterMissingArgumentType } obj := argument.Value.(*ast.ObjectValue) filter, err := NewFilter(obj, filterType)