@@ -30,6 +30,9 @@ defmodule GraphQL do
30
30
# {:ok, %{hello: "world"}}
31
31
"""
32
32
33
+ alias GraphQL.Schema
34
+ alias GraphQL.SyntaxError
35
+
33
36
defmodule ObjectType do
34
37
defstruct name: "RootQueryType" , description: "" , fields: [ ]
35
38
end
@@ -93,47 +96,28 @@ defmodule GraphQL do
93
96
"""
94
97
def execute ( schema , query ) do
95
98
case parse ( query ) do
96
- { :ok , document } -> execute_definition ( hd ( document [ :definitions ] ) , schema )
97
- { :error , error } -> { :error , error }
98
- end
99
- end
99
+ { :ok , document } ->
100
+ query_fields = hd ( document [ :definitions ] ) [ :selectionSet ] [ :selections ]
100
101
101
- defp execute_definition ( % { operation: :query } = definition , schema ) do
102
- { :ok , Enum . map ( definition [ :selectionSet ] [ :selections ] , fn ( selection ) -> execute_field ( selection , schema . query ) end )
103
- |> Enum . filter ( fn ( item ) -> item != nil end )
104
- |> Enum . into ( % { } ) }
105
- end
102
+ % Schema {
103
+ query: _query_root = % ObjectType {
104
+ name: "RootQueryType" ,
105
+ fields: fields
106
+ }
107
+ } = schema
106
108
107
- defp execute_field ( % { kind: :Field , selectionSet: selection_set } = field , schema ) do
108
- fields = Enum . map ( selection_set [ :selections ] , fn ( selection ) ->
109
- schema_fragment = Enum . find ( schema . fields , fn ( fd ) -> fd . name == field [ :name ] end )
110
- execute_field ( selection , schema_fragment )
111
- end )
109
+ result = for fd <- fields , qf <- query_fields , qf [ :name ] == fd . name do
110
+ arguments = Map . get ( qf , :arguments , [ ] )
111
+ |> Enum . map ( & parse_argument / 1 )
112
112
113
- fields = Enum . filter ( fields , fn ( item ) -> item != nil end )
113
+ { String . to_atom ( fd . name ) , fd . resolve . ( arguments ) }
114
+ end
114
115
115
- if Enum . count ( fields ) > 0 do
116
- { String . to_atom ( field [ :name ] ) , Enum . into ( fields , % { } ) }
117
- else
118
- nil
119
- end
120
-
121
- end
122
-
123
- defp execute_field ( % { kind: :Field } = field , schema ) do
124
- arguments = Map . get ( field , :arguments , [ ] ) |> Enum . map ( & parse_argument / 1 )
125
- schema_fragment = Enum . find ( schema . fields , fn ( fd ) -> fd . name == field [ :name ] end )
126
- case resolve ( schema_fragment , arguments ) do
127
- { :ok , value } -> { String . to_atom ( field [ :name ] ) , value }
128
- { :error , _ } -> nil
116
+ { :ok , Enum . into ( result , % { } ) }
117
+ { :error , error } -> { :error , error }
129
118
end
130
119
end
131
120
132
- defp resolve ( nil , _ ) , do: { :error , nil }
133
- defp resolve ( field , arguments ) do
134
- { :ok , field . resolve . ( arguments ) }
135
- end
136
-
137
121
defp parse_argument ( % { kind: :Argument , loc: _ , name: name , value: % { kind: _ , loc: _ , value: value } } ) do
138
122
{ String . to_atom ( name ) , value }
139
123
end
0 commit comments