zf

zenflows testing
git clone https://s.sonu.ch/~srfsh/zf.git
Log | Files | Refs | Submodules | README | LICENSE

input_value_definition.ex (1740B)

      1 defmodule Absinthe.Language.InputValueDefinition do
      2   @moduledoc false
      3 
      4   alias Absinthe.{Blueprint, Language}
      5 
      6   @enforce_keys [:name, :type]
      7   defstruct [
      8     :name,
      9     :type,
     10     description: nil,
     11     default_value: nil,
     12     directives: [],
     13     loc: %{line: nil}
     14   ]
     15 
     16   @type t :: %__MODULE__{
     17           name: String.t(),
     18           description: nil | String.t(),
     19           type: Language.input_t(),
     20           default_value: Language.input_t(),
     21           directives: [Language.Directive.t()],
     22           loc: Language.loc_t()
     23         }
     24 
     25   defimpl Blueprint.Draft do
     26     def convert(node, doc) do
     27       %Blueprint.Schema.InputValueDefinition{
     28         name: Macro.underscore(node.name),
     29         description: node.description,
     30         type: Blueprint.Draft.convert(node.type, doc),
     31         identifier: Macro.underscore(node.name) |> String.to_atom(),
     32         default_value: to_term(node.default_value),
     33         default_value_blueprint: Blueprint.Draft.convert(node.default_value, doc),
     34         directives: Blueprint.Draft.convert(node.directives, doc),
     35         source_location: source_location(node)
     36       }
     37     end
     38 
     39     defp source_location(%{loc: nil}), do: nil
     40     defp source_location(%{loc: loc}), do: Blueprint.SourceLocation.at(loc)
     41 
     42     defp to_term(nil),
     43       do: nil
     44 
     45     defp to_term(%Language.EnumValue{value: value}),
     46       do: value |> Macro.underscore() |> String.to_atom()
     47 
     48     defp to_term(%Language.ListValue{values: values}),
     49       do: Enum.map(values, &to_term/1)
     50 
     51     defp to_term(%Language.NullValue{}),
     52       do: nil
     53 
     54     defp to_term(%Language.ObjectValue{fields: fields}),
     55       do: Enum.into(fields, %{}, &{String.to_atom(&1.name), to_term(&1.value)})
     56 
     57     defp to_term(%{value: value}),
     58       do: value
     59   end
     60 end