gqlparser/gqlparser.go at master · vektah/gqlparser · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
package gqlparser

import (
	"errors"

	"github.com/vektah/gqlparser/v2/ast"
	"github.com/vektah/gqlparser/v2/gqlerror"
	"github.com/vektah/gqlparser/v2/parser"
	"github.com/vektah/gqlparser/v2/validator"
	"github.com/vektah/gqlparser/v2/validator/rules"
)

func LoadSchema(str ...*ast.Source) (*ast.Schema, error) {
	schema, err := validator.LoadSchema(append([]*ast.Source{validator.Prelude}, str...)...)
	gqlErr := &gqlerror.Error{}
	ok := errors.As(err, &gqlErr)
	if ok {
		return schema, gqlErr
	}
	if err != nil {
		return schema, gqlerror.Wrap(err)
	}
	return schema, nil
}

func MustLoadSchema(str ...*ast.Source) *ast.Schema {
	s, err := validator.LoadSchema(append([]*ast.Source{validator.Prelude}, str...)...)
	if err != nil {
		panic(err)
	}
	return s
}

// Deprecated: use LoadQueryWithRules instead.
func LoadQuery(schema *ast.Schema, str string) (*ast.QueryDocument, gqlerror.List) {
	query, err := parser.ParseQuery(&ast.Source{Input: str})
	if err != nil {
		gqlErr := &gqlerror.Error{}
		ok := errors.As(err, &gqlErr)
		if ok {
			return nil, gqlerror.List{gqlErr}
		}
		return nil, gqlerror.List{gqlerror.Wrap(err)}
	}
	errs := validator.Validate(schema, query)
	if len(errs) > 0 {
		return nil, errs
	}

	return query, nil
}

func LoadQueryWithRules(
	schema *ast.Schema,
	str string,
	rules *rules.Rules,
) (*ast.QueryDocument, gqlerror.List) {
	query, err := parser.ParseQuery(&ast.Source{Input: str})
	if err != nil {
		gqlErr := &gqlerror.Error{}
		ok := errors.As(err, &gqlErr)
		if ok {
			return nil, gqlerror.List{gqlErr}
		}
		return nil, gqlerror.List{gqlerror.Wrap(err)}
	}
	errs := validator.ValidateWithRules(schema, query, rules)
	if len(errs) > 0 {
		return nil, errs
	}

	return query, nil
}

// Deprecated: use MustLoadQueryWithRules instead.
func MustLoadQuery(schema *ast.Schema, str string) *ast.QueryDocument {
	q, err := LoadQuery(schema, str)
	if err != nil {
		panic(err)
	}
	return q
}

func MustLoadQueryWithRules(schema *ast.Schema, str string, rules *rules.Rules) *ast.QueryDocument {
	q, err := LoadQueryWithRules(schema, str, rules)
	if err != nil {
		panic(err)
	}
	return q
}