zf

analysis.ex (4815B)

---

 defmodule Absinthe.Phase.Document.Complexity.Analysis do
   @moduledoc false
 
   # Analyses document complexity.
 
   alias Absinthe.{Blueprint, Phase, Complexity, Type}
 
   use Absinthe.Phase
 
   @default_complexity 1
 
   @doc """
   Run complexity analysis.
   """
   @spec run(Blueprint.t(), Keyword.t()) :: Phase.result_t()
   def run(input, options \\ []) do
     if Keyword.get(options, :analyze_complexity, false) do
       do_run(input, options)
     else
       {:ok, input}
     end
   end
 
   defp do_run(input, options) do
     info = info_boilerplate(input, options)
     fragments = process_fragments(input, info)
     fun = &handle_node(&1, info, fragments)
     {:ok, Blueprint.postwalk(input, fun)}
   end
 
   defp process_fragments(input, info) do
     Enum.reduce(input.fragments, %{}, fn fragment, processed ->
       fun = &handle_node(&1, info, processed)
       fragment = Blueprint.postwalk(fragment, fun)
       Map.put(processed, fragment.name, fragment)
     end)
   end
 
   def handle_node(%Blueprint.Document.Fragment.Spread{name: name} = node, _info, fragments) do
     fragment = Map.fetch!(fragments, name)
     %{node | complexity: fragment.complexity}
   end
 
   def handle_node(
         %Blueprint.Document.Fragment.Named{selections: fields} = node,
         _info,
         _fragments
       ) do
     %{node | complexity: sum_complexity(fields)}
   end
 
   def handle_node(
         %Blueprint.Document.Fragment.Inline{selections: fields} = node,
         _info,
         _fragments
       ) do
     %{node | complexity: sum_complexity(fields)}
   end
 
   def handle_node(
         %Blueprint.Document.Field{
           complexity: nil,
           selections: fields,
           argument_data: args,
           schema_node: schema_node
         } = node,
         info,
         _fragments
       ) do
     # NOTE:
     # This really should be more nuanced. If this particular field's schema node
     # is a union type, right now the complexity of:
     # thisField {
     #   ... User { a b c}
     #   ... Dog { x y z }
     # }
     # would be the complexity of `|a, b, c, x, y, z|` despite the fact that it is
     # impossible for `a, b, c` to also happen with `x, y, z`
     #
     # However, if this schema node is an interface type things get complicated quickly.
     # You would have to evaluate the complexity for every possible type which can get
     # pretty unwieldy. For now, simple types it is.
     child_complexity = sum_complexity(fields)
 
     schema_node = %{
       schema_node
       | complexity: Type.function(schema_node, :complexity)
     }
 
     case field_complexity(schema_node, args, child_complexity, info, node) do
       complexity when is_integer(complexity) and complexity >= 0 ->
         %{node | complexity: complexity}
 
       other ->
         raise Absinthe.AnalysisError, field_value_error(node, other)
     end
   end
 
   def handle_node(%Blueprint.Document.Operation{complexity: nil, selections: fields} = node, _, _) do
     %{node | complexity: sum_complexity(fields)}
   end
 
   def handle_node(node, _, _) do
     node
   end
 
   defp field_complexity(%{complexity: nil}, _, child_complexity, _, _) do
     @default_complexity + child_complexity
   end
 
   defp field_complexity(%{complexity: complexity}, arg, child_complexity, _, _)
        when is_function(complexity, 2) do
     complexity.(arg, child_complexity)
   end
 
   defp field_complexity(%{complexity: complexity}, arg, child_complexity, info, node)
        when is_function(complexity, 3) do
     info = struct(Complexity, Map.put(info, :definition, node))
     complexity.(arg, child_complexity, info)
   end
 
   defp field_complexity(%{complexity: {mod, fun}}, arg, child_complexity, info, node) do
     info = struct(Complexity, Map.put(info, :definition, node))
     apply(mod, fun, [arg, child_complexity, info])
   end
 
   defp field_complexity(%{complexity: complexity}, _, _, _, _) do
     complexity
   end
 
   defp field_value_error(field, value) do
     """
     Invalid value returned from complexity analyzer.
 
     Analyzing field:
 
       #{field.name}
 
     Defined at:
 
       #{field.schema_node.__reference__.location.file}:#{
       field.schema_node.__reference__.location.line
     }
 
     Got value:
 
         #{inspect(value)}
 
     The complexity value must be a non negative integer.
     """
   end
 
   defp sum_complexity(fields) do
     Enum.reduce(fields, 0, &sum_complexity/2)
   end
 
   defp sum_complexity(%{complexity: complexity}, acc) when is_nil(complexity) do
     @default_complexity + acc
   end
 
   defp sum_complexity(%{complexity: complexity}, acc) when is_integer(complexity) do
     complexity + acc
   end
 
   # Execution context data that's common to all fields
   defp info_boilerplate(bp_root, options) do
     %{
       context: options[:context] || %{},
       root_value: options[:root_value] || %{},
       schema: bp_root.schema
     }
   end
 end