aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/github.com/graphql-go/graphql/language/printer
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/graphql-go/graphql/language/printer')
-rw-r--r--vendor/github.com/graphql-go/graphql/language/printer/printer.go821
1 files changed, 821 insertions, 0 deletions
diff --git a/vendor/github.com/graphql-go/graphql/language/printer/printer.go b/vendor/github.com/graphql-go/graphql/language/printer/printer.go
new file mode 100644
index 00000000..3add3852
--- /dev/null
+++ b/vendor/github.com/graphql-go/graphql/language/printer/printer.go
@@ -0,0 +1,821 @@
+package printer
+
+import (
+ "fmt"
+ "strings"
+
+ "github.com/graphql-go/graphql/language/ast"
+ "github.com/graphql-go/graphql/language/visitor"
+ "reflect"
+)
+
+func getMapValue(m map[string]interface{}, key string) interface{} {
+ tokens := strings.Split(key, ".")
+ valMap := m
+ for _, token := range tokens {
+ v, ok := valMap[token]
+ if !ok {
+ return nil
+ }
+ switch v := v.(type) {
+ case []interface{}:
+ return v
+ case map[string]interface{}:
+ valMap = v
+ continue
+ default:
+ return v
+ }
+ }
+ return valMap
+}
+func getMapSliceValue(m map[string]interface{}, key string) []interface{} {
+ tokens := strings.Split(key, ".")
+ valMap := m
+ for _, token := range tokens {
+ v, ok := valMap[token]
+ if !ok {
+ return []interface{}{}
+ }
+ switch v := v.(type) {
+ case []interface{}:
+ return v
+ default:
+ return []interface{}{}
+ }
+ }
+ return []interface{}{}
+}
+func getMapValueString(m map[string]interface{}, key string) string {
+ tokens := strings.Split(key, ".")
+ valMap := m
+ for _, token := range tokens {
+ v, ok := valMap[token]
+ if !ok {
+ return ""
+ }
+ if v == nil {
+ return ""
+ }
+ switch v := v.(type) {
+ case map[string]interface{}:
+ valMap = v
+ continue
+ case string:
+ return v
+ default:
+ return fmt.Sprintf("%v", v)
+ }
+ }
+ return ""
+}
+
+func toSliceString(slice interface{}) []string {
+ if slice == nil {
+ return []string{}
+ }
+ res := []string{}
+ switch reflect.TypeOf(slice).Kind() {
+ case reflect.Slice:
+ s := reflect.ValueOf(slice)
+ for i := 0; i < s.Len(); i++ {
+ elem := s.Index(i)
+ elemInterface := elem.Interface()
+ if elem, ok := elemInterface.(string); ok {
+ res = append(res, elem)
+ }
+ }
+ return res
+ default:
+ return res
+ }
+}
+
+func join(str []string, sep string) string {
+ ss := []string{}
+ // filter out empty strings
+ for _, s := range str {
+ if s == "" {
+ continue
+ }
+ ss = append(ss, s)
+ }
+ return strings.Join(ss, sep)
+}
+
+func wrap(start, maybeString, end string) string {
+ if maybeString == "" {
+ return maybeString
+ }
+ return start + maybeString + end
+}
+
+// Given array, print each item on its own line, wrapped in an indented "{ }" block.
+func block(maybeArray interface{}) string {
+ s := toSliceString(maybeArray)
+ if len(s) == 0 {
+ return "{}"
+ }
+ return indent("{\n"+join(s, "\n")) + "\n}"
+}
+
+func indent(maybeString interface{}) string {
+ if maybeString == nil {
+ return ""
+ }
+ switch str := maybeString.(type) {
+ case string:
+ return strings.Replace(str, "\n", "\n ", -1)
+ }
+ return ""
+}
+
+var printDocASTReducer = map[string]visitor.VisitFunc{
+ "Name": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.Name:
+ return visitor.ActionUpdate, node.Value
+ case map[string]interface{}:
+ return visitor.ActionUpdate, getMapValue(node, "Value")
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "Variable": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.Variable:
+ return visitor.ActionUpdate, fmt.Sprintf("$%v", node.Name)
+ case map[string]interface{}:
+ return visitor.ActionUpdate, "$" + getMapValueString(node, "Name")
+ }
+ return visitor.ActionNoChange, nil
+ },
+
+ // Document
+ "Document": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.Document:
+ definitions := toSliceString(node.Definitions)
+ return visitor.ActionUpdate, join(definitions, "\n\n") + "\n"
+ case map[string]interface{}:
+ definitions := toSliceString(getMapValue(node, "Definitions"))
+ return visitor.ActionUpdate, join(definitions, "\n\n") + "\n"
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "OperationDefinition": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.OperationDefinition:
+ op := string(node.Operation)
+ name := fmt.Sprintf("%v", node.Name)
+
+ varDefs := wrap("(", join(toSliceString(node.VariableDefinitions), ", "), ")")
+ directives := join(toSliceString(node.Directives), " ")
+ selectionSet := fmt.Sprintf("%v", node.SelectionSet)
+ // Anonymous queries with no directives or variable definitions can use
+ // the query short form.
+ str := ""
+ if name == "" && directives == "" && varDefs == "" && op == ast.OperationTypeQuery {
+ str = selectionSet
+ } else {
+ str = join([]string{
+ op,
+ join([]string{name, varDefs}, ""),
+ directives,
+ selectionSet,
+ }, " ")
+ }
+ return visitor.ActionUpdate, str
+ case map[string]interface{}:
+
+ op := getMapValueString(node, "Operation")
+ name := getMapValueString(node, "Name")
+
+ varDefs := wrap("(", join(toSliceString(getMapValue(node, "VariableDefinitions")), ", "), ")")
+ directives := join(toSliceString(getMapValue(node, "Directives")), " ")
+ selectionSet := getMapValueString(node, "SelectionSet")
+ str := ""
+ if name == "" && directives == "" && varDefs == "" && op == ast.OperationTypeQuery {
+ str = selectionSet
+ } else {
+ str = join([]string{
+ op,
+ join([]string{name, varDefs}, ""),
+ directives,
+ selectionSet,
+ }, " ")
+ }
+ return visitor.ActionUpdate, str
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "VariableDefinition": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.VariableDefinition:
+ variable := fmt.Sprintf("%v", node.Variable)
+ ttype := fmt.Sprintf("%v", node.Type)
+ defaultValue := fmt.Sprintf("%v", node.DefaultValue)
+
+ return visitor.ActionUpdate, variable + ": " + ttype + wrap(" = ", defaultValue, "")
+ case map[string]interface{}:
+
+ variable := getMapValueString(node, "Variable")
+ ttype := getMapValueString(node, "Type")
+ defaultValue := getMapValueString(node, "DefaultValue")
+
+ return visitor.ActionUpdate, variable + ": " + ttype + wrap(" = ", defaultValue, "")
+
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "SelectionSet": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.SelectionSet:
+ str := block(node.Selections)
+ return visitor.ActionUpdate, str
+ case map[string]interface{}:
+ selections := getMapValue(node, "Selections")
+ str := block(selections)
+ return visitor.ActionUpdate, str
+
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "Field": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.Argument:
+ name := fmt.Sprintf("%v", node.Name)
+ value := fmt.Sprintf("%v", node.Value)
+ return visitor.ActionUpdate, name + ": " + value
+ case map[string]interface{}:
+
+ alias := getMapValueString(node, "Alias")
+ name := getMapValueString(node, "Name")
+ args := toSliceString(getMapValue(node, "Arguments"))
+ directives := toSliceString(getMapValue(node, "Directives"))
+ selectionSet := getMapValueString(node, "SelectionSet")
+
+ str := join(
+ []string{
+ wrap("", alias, ": ") + name + wrap("(", join(args, ", "), ")"),
+ join(directives, " "),
+ selectionSet,
+ },
+ " ",
+ )
+ return visitor.ActionUpdate, str
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "Argument": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.FragmentSpread:
+ name := fmt.Sprintf("%v", node.Name)
+ directives := toSliceString(node.Directives)
+ return visitor.ActionUpdate, "..." + name + wrap(" ", join(directives, " "), "")
+ case map[string]interface{}:
+ name := getMapValueString(node, "Name")
+ value := getMapValueString(node, "Value")
+ return visitor.ActionUpdate, name + ": " + value
+ }
+ return visitor.ActionNoChange, nil
+ },
+
+ // Fragments
+ "FragmentSpread": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.InlineFragment:
+ typeCondition := fmt.Sprintf("%v", node.TypeCondition)
+ directives := toSliceString(node.Directives)
+ selectionSet := fmt.Sprintf("%v", node.SelectionSet)
+ return visitor.ActionUpdate, "... on " + typeCondition + " " + wrap("", join(directives, " "), " ") + selectionSet
+ case map[string]interface{}:
+ name := getMapValueString(node, "Name")
+ directives := toSliceString(getMapValue(node, "Directives"))
+ return visitor.ActionUpdate, "..." + name + wrap(" ", join(directives, " "), "")
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "InlineFragment": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case map[string]interface{}:
+ typeCondition := getMapValueString(node, "TypeCondition")
+ directives := toSliceString(getMapValue(node, "Directives"))
+ selectionSet := getMapValueString(node, "SelectionSet")
+ return visitor.ActionUpdate,
+ join([]string{
+ "...",
+ wrap("on ", typeCondition, ""),
+ join(directives, " "),
+ selectionSet,
+ }, " ")
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "FragmentDefinition": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.FragmentDefinition:
+ name := fmt.Sprintf("%v", node.Name)
+ typeCondition := fmt.Sprintf("%v", node.TypeCondition)
+ directives := toSliceString(node.Directives)
+ selectionSet := fmt.Sprintf("%v", node.SelectionSet)
+ return visitor.ActionUpdate, "fragment " + name + " on " + typeCondition + " " + wrap("", join(directives, " "), " ") + selectionSet
+ case map[string]interface{}:
+ name := getMapValueString(node, "Name")
+ typeCondition := getMapValueString(node, "TypeCondition")
+ directives := toSliceString(getMapValue(node, "Directives"))
+ selectionSet := getMapValueString(node, "SelectionSet")
+ return visitor.ActionUpdate, "fragment " + name + " on " + typeCondition + " " + wrap("", join(directives, " "), " ") + selectionSet
+ }
+ return visitor.ActionNoChange, nil
+ },
+
+ // Value
+ "IntValue": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.IntValue:
+ return visitor.ActionUpdate, fmt.Sprintf("%v", node.Value)
+ case map[string]interface{}:
+ return visitor.ActionUpdate, getMapValueString(node, "Value")
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "FloatValue": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.FloatValue:
+ return visitor.ActionUpdate, fmt.Sprintf("%v", node.Value)
+ case map[string]interface{}:
+ return visitor.ActionUpdate, getMapValueString(node, "Value")
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "StringValue": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.StringValue:
+ return visitor.ActionUpdate, `"` + fmt.Sprintf("%v", node.Value) + `"`
+ case map[string]interface{}:
+ return visitor.ActionUpdate, `"` + getMapValueString(node, "Value") + `"`
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "BooleanValue": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.BooleanValue:
+ return visitor.ActionUpdate, fmt.Sprintf("%v", node.Value)
+ case map[string]interface{}:
+ return visitor.ActionUpdate, getMapValueString(node, "Value")
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "EnumValue": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.EnumValue:
+ return visitor.ActionUpdate, fmt.Sprintf("%v", node.Value)
+ case map[string]interface{}:
+ return visitor.ActionUpdate, getMapValueString(node, "Value")
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "ListValue": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.ListValue:
+ return visitor.ActionUpdate, "[" + join(toSliceString(node.Values), ", ") + "]"
+ case map[string]interface{}:
+ return visitor.ActionUpdate, "[" + join(toSliceString(getMapValue(node, "Values")), ", ") + "]"
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "ObjectValue": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.ObjectValue:
+ return visitor.ActionUpdate, "{" + join(toSliceString(node.Fields), ", ") + "}"
+ case map[string]interface{}:
+ return visitor.ActionUpdate, "{" + join(toSliceString(getMapValue(node, "Fields")), ", ") + "}"
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "ObjectField": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.ObjectField:
+ name := fmt.Sprintf("%v", node.Name)
+ value := fmt.Sprintf("%v", node.Value)
+ return visitor.ActionUpdate, name + ": " + value
+ case map[string]interface{}:
+ name := getMapValueString(node, "Name")
+ value := getMapValueString(node, "Value")
+ return visitor.ActionUpdate, name + ": " + value
+ }
+ return visitor.ActionNoChange, nil
+ },
+
+ // Directive
+ "Directive": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.Directive:
+ name := fmt.Sprintf("%v", node.Name)
+ args := toSliceString(node.Arguments)
+ return visitor.ActionUpdate, "@" + name + wrap("(", join(args, ", "), ")")
+ case map[string]interface{}:
+ name := getMapValueString(node, "Name")
+ args := toSliceString(getMapValue(node, "Arguments"))
+ return visitor.ActionUpdate, "@" + name + wrap("(", join(args, ", "), ")")
+ }
+ return visitor.ActionNoChange, nil
+ },
+
+ // Type
+ "Named": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.Named:
+ return visitor.ActionUpdate, fmt.Sprintf("%v", node.Name)
+ case map[string]interface{}:
+ return visitor.ActionUpdate, getMapValueString(node, "Name")
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "List": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.List:
+ return visitor.ActionUpdate, "[" + fmt.Sprintf("%v", node.Type) + "]"
+ case map[string]interface{}:
+ return visitor.ActionUpdate, "[" + getMapValueString(node, "Type") + "]"
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "NonNull": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.NonNull:
+ return visitor.ActionUpdate, fmt.Sprintf("%v", node.Type) + "!"
+ case map[string]interface{}:
+ return visitor.ActionUpdate, getMapValueString(node, "Type") + "!"
+ }
+ return visitor.ActionNoChange, nil
+ },
+
+ // Type System Definitions
+ "SchemaDefinition": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.SchemaDefinition:
+ directives := []string{}
+ for _, directive := range node.Directives {
+ directives = append(directives, fmt.Sprintf("%v", directive.Name))
+ }
+ str := join([]string{
+ "schema",
+ join(directives, " "),
+ block(node.OperationTypes),
+ }, " ")
+ return visitor.ActionUpdate, str
+ case map[string]interface{}:
+ operationTypes := toSliceString(getMapValue(node, "OperationTypes"))
+ directives := []string{}
+ for _, directive := range getMapSliceValue(node, "Directives") {
+ directives = append(directives, fmt.Sprintf("%v", directive))
+ }
+ str := join([]string{
+ "schema",
+ join(directives, " "),
+ block(operationTypes),
+ }, " ")
+ return visitor.ActionUpdate, str
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "OperationTypeDefinition": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.OperationTypeDefinition:
+ str := fmt.Sprintf("%v: %v", node.Operation, node.Type)
+ return visitor.ActionUpdate, str
+ case map[string]interface{}:
+ operation := getMapValueString(node, "Operation")
+ ttype := getMapValueString(node, "Type")
+ str := fmt.Sprintf("%v: %v", operation, ttype)
+ return visitor.ActionUpdate, str
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "ScalarDefinition": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.ScalarDefinition:
+ directives := []string{}
+ for _, directive := range node.Directives {
+ directives = append(directives, fmt.Sprintf("%v", directive.Name))
+ }
+ str := join([]string{
+ "scalar",
+ fmt.Sprintf("%v", node.Name),
+ join(directives, " "),
+ }, " ")
+ return visitor.ActionUpdate, str
+ case map[string]interface{}:
+ name := getMapValueString(node, "Name")
+ directives := []string{}
+ for _, directive := range getMapSliceValue(node, "Directives") {
+ directives = append(directives, fmt.Sprintf("%v", directive))
+ }
+ str := join([]string{
+ "scalar",
+ name,
+ join(directives, " "),
+ }, " ")
+ return visitor.ActionUpdate, str
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "ObjectDefinition": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.ObjectDefinition:
+ name := fmt.Sprintf("%v", node.Name)
+ interfaces := toSliceString(node.Interfaces)
+ fields := node.Fields
+ directives := []string{}
+ for _, directive := range node.Directives {
+ directives = append(directives, fmt.Sprintf("%v", directive.Name))
+ }
+ str := join([]string{
+ "type",
+ name,
+ wrap("implements ", join(interfaces, ", "), ""),
+ join(directives, " "),
+ block(fields),
+ }, " ")
+ return visitor.ActionUpdate, str
+ case map[string]interface{}:
+ name := getMapValueString(node, "Name")
+ interfaces := toSliceString(getMapValue(node, "Interfaces"))
+ fields := getMapValue(node, "Fields")
+ directives := []string{}
+ for _, directive := range getMapSliceValue(node, "Directives") {
+ directives = append(directives, fmt.Sprintf("%v", directive))
+ }
+ str := join([]string{
+ "type",
+ name,
+ wrap("implements ", join(interfaces, ", "), ""),
+ join(directives, " "),
+ block(fields),
+ }, " ")
+ return visitor.ActionUpdate, str
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "FieldDefinition": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.FieldDefinition:
+ name := fmt.Sprintf("%v", node.Name)
+ ttype := fmt.Sprintf("%v", node.Type)
+ args := toSliceString(node.Arguments)
+ directives := []string{}
+ for _, directive := range node.Directives {
+ directives = append(directives, fmt.Sprintf("%v", directive.Name))
+ }
+ str := name + wrap("(", join(args, ", "), ")") + ": " + ttype + wrap(" ", join(directives, " "), "")
+ return visitor.ActionUpdate, str
+ case map[string]interface{}:
+ name := getMapValueString(node, "Name")
+ ttype := getMapValueString(node, "Type")
+ args := toSliceString(getMapValue(node, "Arguments"))
+ directives := []string{}
+ for _, directive := range getMapSliceValue(node, "Directives") {
+ directives = append(directives, fmt.Sprintf("%v", directive))
+ }
+ str := name + wrap("(", join(args, ", "), ")") + ": " + ttype + wrap(" ", join(directives, " "), "")
+ return visitor.ActionUpdate, str
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "InputValueDefinition": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.InputValueDefinition:
+ name := fmt.Sprintf("%v", node.Name)
+ ttype := fmt.Sprintf("%v", node.Type)
+ defaultValue := fmt.Sprintf("%v", node.DefaultValue)
+ directives := []string{}
+ for _, directive := range node.Directives {
+ directives = append(directives, fmt.Sprintf("%v", directive.Name))
+ }
+ str := join([]string{
+ name + ": " + ttype,
+ wrap("= ", defaultValue, ""),
+ join(directives, " "),
+ }, " ")
+
+ return visitor.ActionUpdate, str
+ case map[string]interface{}:
+ name := getMapValueString(node, "Name")
+ ttype := getMapValueString(node, "Type")
+ defaultValue := getMapValueString(node, "DefaultValue")
+ directives := []string{}
+ for _, directive := range getMapSliceValue(node, "Directives") {
+ directives = append(directives, fmt.Sprintf("%v", directive))
+ }
+ str := join([]string{
+ name + ": " + ttype,
+ wrap("= ", defaultValue, ""),
+ join(directives, " "),
+ }, " ")
+ return visitor.ActionUpdate, str
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "InterfaceDefinition": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.InterfaceDefinition:
+ name := fmt.Sprintf("%v", node.Name)
+ fields := node.Fields
+ directives := []string{}
+ for _, directive := range node.Directives {
+ directives = append(directives, fmt.Sprintf("%v", directive.Name))
+ }
+ str := join([]string{
+ "interface",
+ name,
+ join(directives, " "),
+ block(fields),
+ }, " ")
+ return visitor.ActionUpdate, str
+ case map[string]interface{}:
+ name := getMapValueString(node, "Name")
+ fields := getMapValue(node, "Fields")
+ directives := []string{}
+ for _, directive := range getMapSliceValue(node, "Directives") {
+ directives = append(directives, fmt.Sprintf("%v", directive))
+ }
+ str := join([]string{
+ "interface",
+ name,
+ join(directives, " "),
+ block(fields),
+ }, " ")
+ return visitor.ActionUpdate, str
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "UnionDefinition": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.UnionDefinition:
+ name := fmt.Sprintf("%v", node.Name)
+ types := toSliceString(node.Types)
+ directives := []string{}
+ for _, directive := range node.Directives {
+ directives = append(directives, fmt.Sprintf("%v", directive.Name))
+ }
+ str := join([]string{
+ "union",
+ name,
+ join(directives, " "),
+ "= " + join(types, " | "),
+ }, " ")
+ return visitor.ActionUpdate, str
+ case map[string]interface{}:
+ name := getMapValueString(node, "Name")
+ types := toSliceString(getMapValue(node, "Types"))
+ directives := []string{}
+ for _, directive := range getMapSliceValue(node, "Directives") {
+ directives = append(directives, fmt.Sprintf("%v", directive))
+ }
+ str := join([]string{
+ "union",
+ name,
+ join(directives, " "),
+ "= " + join(types, " | "),
+ }, " ")
+ return visitor.ActionUpdate, str
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "EnumDefinition": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.EnumDefinition:
+ name := fmt.Sprintf("%v", node.Name)
+ values := node.Values
+ directives := []string{}
+ for _, directive := range node.Directives {
+ directives = append(directives, fmt.Sprintf("%v", directive.Name))
+ }
+ str := join([]string{
+ "enum",
+ name,
+ join(directives, " "),
+ block(values),
+ }, " ")
+ return visitor.ActionUpdate, str
+ case map[string]interface{}:
+ name := getMapValueString(node, "Name")
+ values := getMapValue(node, "Values")
+ directives := []string{}
+ for _, directive := range getMapSliceValue(node, "Directives") {
+ directives = append(directives, fmt.Sprintf("%v", directive))
+ }
+ str := join([]string{
+ "enum",
+ name,
+ join(directives, " "),
+ block(values),
+ }, " ")
+ return visitor.ActionUpdate, str
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "EnumValueDefinition": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.EnumValueDefinition:
+ name := fmt.Sprintf("%v", node.Name)
+ directives := []string{}
+ for _, directive := range node.Directives {
+ directives = append(directives, fmt.Sprintf("%v", directive.Name))
+ }
+ str := join([]string{
+ name,
+ join(directives, " "),
+ }, " ")
+ return visitor.ActionUpdate, str
+ case map[string]interface{}:
+ name := getMapValueString(node, "Name")
+ directives := []string{}
+ for _, directive := range getMapSliceValue(node, "Directives") {
+ directives = append(directives, fmt.Sprintf("%v", directive))
+ }
+ str := join([]string{
+ name,
+ join(directives, " "),
+ }, " ")
+ return visitor.ActionUpdate, str
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "InputObjectDefinition": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.InputObjectDefinition:
+ name := fmt.Sprintf("%v", node.Name)
+ fields := node.Fields
+ directives := []string{}
+ for _, directive := range node.Directives {
+ directives = append(directives, fmt.Sprintf("%v", directive.Name))
+ }
+ str := join([]string{
+ "input",
+ name,
+ join(directives, " "),
+ block(fields),
+ }, " ")
+ return visitor.ActionUpdate, str
+ case map[string]interface{}:
+ name := getMapValueString(node, "Name")
+ fields := getMapValue(node, "Fields")
+ directives := []string{}
+ for _, directive := range getMapSliceValue(node, "Directives") {
+ directives = append(directives, fmt.Sprintf("%v", directive))
+ }
+ str := join([]string{
+ "input",
+ name,
+ join(directives, " "),
+ block(fields),
+ }, " ")
+ return visitor.ActionUpdate, str
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "TypeExtensionDefinition": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.TypeExtensionDefinition:
+ definition := fmt.Sprintf("%v", node.Definition)
+ str := "extend " + definition
+ return visitor.ActionUpdate, str
+ case map[string]interface{}:
+ definition := getMapValueString(node, "Definition")
+ str := "extend " + definition
+ return visitor.ActionUpdate, str
+ }
+ return visitor.ActionNoChange, nil
+ },
+ "DirectiveDefinition": func(p visitor.VisitFuncParams) (string, interface{}) {
+ switch node := p.Node.(type) {
+ case *ast.DirectiveDefinition:
+ args := wrap("(", join(toSliceString(node.Arguments), ", "), ")")
+ str := fmt.Sprintf("directive @%v%v on %v", node.Name, args, join(toSliceString(node.Locations), " | "))
+ return visitor.ActionUpdate, str
+ case map[string]interface{}:
+ name := getMapValueString(node, "Name")
+ locations := toSliceString(getMapValue(node, "Locations"))
+ args := toSliceString(getMapValue(node, "Arguments"))
+ argsStr := wrap("(", join(args, ", "), ")")
+ str := fmt.Sprintf("directive @%v%v on %v", name, argsStr, join(locations, " | "))
+ return visitor.ActionUpdate, str
+ }
+ return visitor.ActionNoChange, nil
+ },
+}
+
+func Print(astNode ast.Node) (printed interface{}) {
+ defer func() interface{} {
+ if r := recover(); r != nil {
+ return fmt.Sprintf("%v", astNode)
+ }
+ return printed
+ }()
+ printed = visitor.Visit(astNode, &visitor.VisitorOptions{
+ LeaveKindMap: printDocASTReducer,
+ }, nil)
+ return printed
+}
generated by cgit (git 2.34.1) at 2024-10-20 05:35:18 +0000