zf

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

inline_functions.ex (2434B)

      1 defmodule Absinthe.Phase.Schema.InlineFunctions do
      2   @moduledoc false
      3 
      4   use Absinthe.Phase
      5   alias Absinthe.Blueprint
      6   alias Absinthe.Blueprint.Schema
      7   alias Absinthe.Type
      8 
      9   def run(blueprint, opts) do
     10     blueprint = Blueprint.prewalk(blueprint, &inline_functions(&1, blueprint.schema, opts))
     11 
     12     {:ok, blueprint}
     13   end
     14 
     15   def inline_functions(%Schema.SchemaDefinition{} = schema_def, schema, opts) do
     16     schema_def = %{
     17       schema_def
     18       | type_artifacts: Enum.map(schema_def.type_artifacts, &inline_functions(&1, schema, opts)),
     19         directive_artifacts:
     20           Enum.map(schema_def.directive_artifacts, &inline_functions(&1, schema, opts))
     21     }
     22 
     23     {:halt, schema_def}
     24   end
     25 
     26   def inline_functions(%type{identifier: _} = node, schema, opts) do
     27     type
     28     |> Schema.functions()
     29     # middleware gets handled specially
     30     |> Enum.reject(&(&1 in [:middleware]))
     31     |> Enum.reduce(node, &inline_function(&1, &2, opts))
     32     |> inline_middleware(schema, opts)
     33   end
     34 
     35   def inline_functions(node, _, _) do
     36     node
     37   end
     38 
     39   defp inline_function(attr, node, opts) do
     40     function = Type.function(node, attr)
     41 
     42     if Absinthe.Utils.escapable?(function) || opts[:inline_always] do
     43       %{node | attr => function}
     44     else
     45       node
     46     end
     47   end
     48 
     49   def inline_middleware(%type_name{} = type, schema, opts)
     50       when type_name in [Type.Object, Type.Union, Type.Interface] do
     51     Map.update!(type, :fields, fn fields ->
     52       fields =
     53         Enum.map(fields, fn {field_ident, field} ->
     54           {field_ident, inline_functions(field, schema, opts)}
     55         end)
     56 
     57       Map.new(fields, fn
     58         {field_ident, %{middleware: middleware} = field} ->
     59           expanded_middleware = Absinthe.Middleware.expand(schema, middleware, field, type)
     60 
     61           if Absinthe.Utils.escapable?(expanded_middleware) || opts[:inline_always] do
     62             {field_ident, %{field | middleware: expanded_middleware}}
     63           else
     64             middleware_shim = {
     65               {Absinthe.Middleware, :shim},
     66               {type.identifier, field.identifier, middleware}
     67             }
     68 
     69             {field_ident, %{field | middleware: [middleware_shim]}}
     70           end
     71 
     72         {field_ident, field} ->
     73           middleware = Absinthe.Middleware.expand(schema, field.middleware, field, type)
     74 
     75           {field_ident, %{field | middleware: middleware}}
     76       end)
     77     end)
     78   end
     79 
     80   def inline_middleware(type, _, _) do
     81     type
     82   end
     83 end