zf

lone_anonymous_operation.ex (1636B)

---

 defmodule Absinthe.Phase.Document.Validation.LoneAnonymousOperation do
   @moduledoc false
 
   # Validates document to ensure that only one operation is provided without
   # a name.
 
   alias Absinthe.{Blueprint, Phase}
 
   use Absinthe.Phase
   use Absinthe.Phase.Validation
 
   @doc """
   Run the validation.
   """
   @spec run(Blueprint.t(), Keyword.t()) :: Phase.result_t()
   def run(input, _options \\ []) do
     result = Blueprint.prewalk(input, &handle_node/1)
     {:ok, result}
   end
 
   # Find the root and check for multiple anonymous operations
   @spec handle_node(Blueprint.node_t()) :: Blueprint.node_t()
   defp handle_node(%Blueprint{} = node) do
     ops = process(node.operations)
     %{node | operations: ops}
   end
 
   defp handle_node(node) do
     node
   end
 
   @spec process([Blueprint.Document.Operation.t()]) :: [Blueprint.Document.Operation.t()]
   defp process(operations) do
     do_process(operations, length(operations))
   end
 
   @spec do_process([Blueprint.Document.Operation.t()], integer) :: [
           Blueprint.Document.Operation.t()
         ]
   defp do_process(operations, count) when count < 2 do
     operations
   end
 
   defp do_process(operations, _) do
     Enum.map(operations, fn
       %{name: nil} = op ->
         flag_invalid(op, :bad_name)
         |> put_error(error(op))
 
       other ->
         other
     end)
   end
 
   # Generate the error for the node
   @spec error(Blueprint.node_t()) :: Phase.Error.t()
   defp error(node) do
     %Phase.Error{
       phase: __MODULE__,
       message: "This anonymous operation must be the only defined operation.",
       locations: [node.source_location]
     }
   end
 end