graphql 1.10.0.pre1 → 1.10.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d8cd9472c04900ca59a46d06eedf501e09d1f0561a5df1c902faada7c9536df
-  data.tar.gz: 409d5ef50405fe5f6ca2f1c197e9c98696c3b89bbf35323e325e7a4bc157419c
+  metadata.gz: 0b0dea1cf870243e0c1ca99c9aa276b3ab6dca48c94048d99033c7e868d6edb7
+  data.tar.gz: a9067feb798b969d50e6cd3b436432adba4216ad8b66d58cd8cde2d76f9d5589
 SHA512:
-  metadata.gz: '0511959efa6a890699def5ea1d681ed9000435903f078955ecdf0a4f4c1be409ea542cd8e8b9cced7f22e22df49115038bbb544d611b9f66a6fdb5ae75c92566'
-  data.tar.gz: cb29aa9f21e13c65d4b700720cd2079968f6f6b709712e464133f78c383841c219c24bce7a5ffe6b6dd6577c6e7c03f282f259dca73896b669d2cfcaaa072abe
+  metadata.gz: d2effe2d2074b17026c7c6e3ddc71db82b1bd17ce8624dbdd9a88345ff39b2177ae48981deabdda227fb4bcf965469a5e874faeb76c0830d598fdb5501673c98
+  data.tar.gz: 810111555e1713e4d0d6afabba7102a03f458349d135d92f573236feedd116d81481ba7119c364d9533d39f1d98aa940ce32dc7d452008f6c00827796e5794ef

data/lib/generators/graphql/core.rb

@@ -25,6 +25,7 @@ module Graphql
 
       def create_mutation_root_type
         create_dir("#{options[:directory]}/mutations")
+        template("base_mutation.erb", "#{options[:directory]}/mutations/base_mutation.rb", { skip: true })
         template("mutation_type.erb", "#{options[:directory]}/types/mutation_type.rb", { skip: true })
         insert_root_type('mutation', 'MutationType')
       end

data/lib/generators/graphql/install_generator.rb

@@ -24,6 +24,7 @@ module Graphql
     #       - query_type.rb
     #     - loaders/
     #     - mutations/
+    #       - base_mutation.rb
     #     - {app_name}_schema.rb
     # ```
     #

data/lib/generators/graphql/mutation_generator.rb

@@ -45,7 +45,7 @@ module Graphql
       private
 
       def assign_names!(name)
-        @field_name = name.camelize(:lower)
+        @field_name = name.camelize.underscore
         @mutation_name = name.camelize(:upper)
         @file_name = name.camelize.underscore
       end

data/lib/generators/graphql/templates/base_field.erb

@@ -1,9 +1,5 @@
 module Types
   class BaseField < GraphQL::Schema::Field
     argument_class Types::BaseArgument
-
-    def resolve_field(obj, args, ctx)
-      resolve(obj, args, ctx)
-    end
   end
 end

data/lib/generators/graphql/templates/base_mutation.erb

@@ -0,0 +1,8 @@
+module Mutations
+  class BaseMutation < GraphQL::Schema::RelayClassicMutation
+    argument_class Types::BaseArgument
+    field_class Types::BaseField
+    input_object_class Types::BaseInputObject
+    object_class Types::BaseObject
+  end
+end

data/lib/generators/graphql/templates/graphql_controller.erb

@@ -1,4 +1,9 @@
 class GraphqlController < ApplicationController
+  # If accessing from outside this domain, nullify the session
+  # This allows for outside API access while preventing CSRF attacks,
+  # but you'll have to authenticate your user separately
+  # protect_from_forgery with: :null_session
+
   def execute
     variables = ensure_hash(params[:variables])
     query = params[:query]

data/lib/generators/graphql/templates/mutation.erb

@@ -1,5 +1,5 @@
 module Mutations
-  class <%= mutation_name %> < GraphQL::Schema::RelayClassicMutation
+  class <%= mutation_name %> < BaseMutation
     # TODO: define return fields
     # field :post, Types::PostType, null: false
 

data/lib/generators/graphql/templates/schema.erb

@@ -24,7 +24,7 @@ class <%= schema_name %> < GraphQL::Schema
   def self.resolve_type(type, obj, ctx)
     # TODO: Implement this function
     # to return the correct type for `obj`
-    raise(NotImplementedError)
+    raise(GraphQL::RequiredImplementationMissingError)
   end
 <% end %><% if options[:batch] %>
   # GraphQL::Batch setup:

data/lib/graphql.rb

@@ -10,6 +10,9 @@ module GraphQL
   class Error < StandardError
   end
 
+  class RequiredImplementationMissingError < Error
+  end
+
   # Turn a query string or schema definition into an AST
   # @param graphql_string [String] a GraphQL query string or schema definition
   # @return [GraphQL::Language::Nodes::Document]
@@ -81,6 +84,7 @@ require "graphql/tracing"
 require "graphql/execution"
 require "graphql/dig"
 require "graphql/schema"
+require "graphql/query"
 require "graphql/directive"
 require "graphql/execution"
 require "graphql/types"
@@ -104,7 +108,6 @@ require "graphql/invalid_name_error"
 require "graphql/unresolved_type_error"
 require "graphql/integer_encoding_error"
 require "graphql/string_encoding_error"
-require "graphql/query"
 require "graphql/internal_representation"
 require "graphql/static_validation"
 require "graphql/version"

data/lib/graphql/analysis/ast.rb

@@ -12,9 +12,8 @@ module GraphQL
     module AST
       module_function
 
-      def use(schema_defn)
-        schema = schema_defn.target
-        schema.analysis_engine = GraphQL::Analysis::AST
+      def use(schema_class)
+        schema_class.analysis_engine = GraphQL::Analysis::AST
       end
 
       # Analyze a multiplex, and all queries within.
@@ -23,7 +22,7 @@ module GraphQL
       #
       # @param multiplex [GraphQL::Execution::Multiplex]
       # @param analyzers [Array<GraphQL::Analysis::AST::Analyzer>]
-      # @return [void]
+      # @return [Array<Any>] Results from multiplex analyzers
       def analyze_multiplex(multiplex, analyzers)
         multiplex_analyzers = analyzers.map { |analyzer| analyzer.new(multiplex) }
 
@@ -46,8 +45,8 @@ module GraphQL
           multiplex.queries.each_with_index do |query, idx|
             query.analysis_errors = multiplex_errors + analysis_errors(query_results[idx])
           end
+          multiplex_results
         end
-        nil
       end
 
       # @param query [GraphQL::Query]
@@ -60,16 +59,18 @@ module GraphQL
             .select { |analyzer| analyzer.analyze? }
 
           analyzers_to_run = query_analyzers + multiplex_analyzers
-          return [] unless analyzers_to_run.any?
+          if analyzers_to_run.any?
+            visitor = GraphQL::Analysis::AST::Visitor.new(
+              query: query,
+              analyzers: analyzers_to_run
+            )
 
-          visitor = GraphQL::Analysis::AST::Visitor.new(
-            query: query,
-            analyzers: analyzers_to_run
-          )
+            visitor.visit
 
-          visitor.visit
-
-          query_analyzers.map(&:result)
+            query_analyzers.map(&:result)
+          else
+            []
+          end
         end
       end
 

data/lib/graphql/analysis/ast/analyzer.rb

@@ -5,10 +5,21 @@ module GraphQL
       # Query analyzer for query ASTs. Query analyzers respond to visitor style methods
       # but are prefixed by `enter` and `leave`.
       #
-      # @param [GraphQL::Query] The query to analyze
+      # When an analyzer is initialized with a Multiplex, you can always get the current query from
+      # `visitor.query` in the visit methods.
+      #
+      # @param [GraphQL::Query, GraphQL::Execution::Multiplex] The query or multiplex to analyze
       class Analyzer
-        def initialize(query)
-          @query = query
+        def initialize(subject)
+          @subject = subject
+
+          if subject.is_a?(GraphQL::Query)
+            @query = subject
+            @multiplex = nil
+          else
+            @multiplex = subject
+            @query = nil
+          end
         end
 
         # Analyzer hook to decide at analysis time whether a query should
@@ -22,7 +33,7 @@ module GraphQL
         # in a query error.
         # @return [Any] The analyzer result
         def result
-          raise NotImplementedError
+          raise GraphQL::RequiredImplementationMissingError
         end
 
         class << self
@@ -58,7 +69,15 @@ module GraphQL
 
         protected
 
+        # @return [GraphQL::Query, GraphQL::Execution::Multiplex] Whatever this analyzer is analyzing
+        attr_reader :subject
+
+        # @return [GraphQL::Query, nil] `nil` if this analyzer is visiting a multiplex
+        #  (When this is `nil`, use `visitor.query` inside visit methods to get the current query)
         attr_reader :query
+
+        # @return [GraphQL::Execution::Multiplex, nil] `nil` if this analyzer is visiting a query
+        attr_reader :multiplex
       end
     end
   end

data/lib/graphql/analysis/ast/field_usage.rb

@@ -11,7 +11,7 @@ module GraphQL
 
         def on_leave_field(node, parent, visitor)
           field_defn = visitor.field_definition
-          field = "#{visitor.parent_type_definition.name}.#{field_defn.name}"
+          field = "#{visitor.parent_type_definition.graphql_name}.#{field_defn.graphql_name}"
           @used_fields << field
           @used_deprecated_fields << field if field_defn.deprecation_reason
         end

data/lib/graphql/analysis/ast/max_query_complexity.rb

@@ -7,12 +7,12 @@ module GraphQL
       # see {Schema#max_complexity} and {Query#max_complexity}
       class MaxQueryComplexity < QueryComplexity
         def result
-          return if query.max_complexity.nil?
+          return if subject.max_complexity.nil?
 
           total_complexity = max_possible_complexity
 
-          if total_complexity > query.max_complexity
-            GraphQL::AnalysisError.new("Query has complexity of #{total_complexity}, which exceeds max complexity of #{query.max_complexity}")
+          if total_complexity > subject.max_complexity
+            GraphQL::AnalysisError.new("Query has complexity of #{total_complexity}, which exceeds max complexity of #{subject.max_complexity}")
           else
             nil
           end

data/lib/graphql/analysis/ast/max_query_depth.rb

@@ -4,10 +4,14 @@ module GraphQL
     module AST
       class MaxQueryDepth < QueryDepth
         def result
-          return unless query.max_depth
+          configured_max_depth = if query
+            query.max_depth
+          else
+            multiplex.schema.max_depth
+          end
 
-          if @max_depth > query.max_depth
-            GraphQL::AnalysisError.new("Query has depth of #{@max_depth}, which exceeds max depth of #{query.max_depth}")
+          if configured_max_depth && @max_depth > configured_max_depth
+            GraphQL::AnalysisError.new("Query has depth of #{@max_depth}, which exceeds max depth of #{configured_max_depth}")
           else
             nil
           end

data/lib/graphql/analysis/ast/query_complexity.rb

@@ -42,7 +42,7 @@ module GraphQL
           if @complexities_on_type.last.is_a?(AbstractTypeComplexity)
             key = selection_key(visitor.response_path, visitor.query)
             parent_type = visitor.parent_type_definition
-            query.possible_types(parent_type).each do |type|
+            visitor.query.possible_types(parent_type).each do |type|
               @complexities_on_type.last.merge(type, key, own_complexity)
             end
           else
@@ -74,7 +74,7 @@ module GraphQL
 
           case defined_complexity
           when Proc
-            defined_complexity.call(query.context, arguments, child_complexity)
+            defined_complexity.call(visitor.query.context, arguments, child_complexity)
           when Numeric
             defined_complexity + (child_complexity || 0)
           else

data/lib/graphql/analysis/ast/visitor.rb

@@ -134,7 +134,7 @@ module GraphQL
           argument_defn = if (arg = @argument_definitions.last)
             arg_type = arg.type.unwrap
             if arg_type.kind.input_object?
-              arg_type.input_fields[node.name]
+              arg_type.arguments[node.name]
             else
               nil
             end
@@ -214,7 +214,7 @@ module GraphQL
           fragment_def = query.fragments[fragment_spread.name]
 
           object_type = if fragment_def.type
-            query.schema.types.fetch(fragment_def.type.name, nil)
+            @query.warden.get_type(fragment_def.type.name)
           else
             object_types.last
           end
@@ -245,7 +245,7 @@ module GraphQL
 
         def on_fragment_with_type(node)
           object_type = if node.type
-            @schema.types.fetch(node.type.name, nil)
+            @query.warden.get_type(node.type.name)
           else
             @object_types.last
           end

data/lib/graphql/base_type.rb

@@ -171,7 +171,7 @@ module GraphQL
     end
 
     def coerce_result(value, ctx)
-      raise NotImplementedError
+      raise GraphQL::RequiredImplementationMissingError
     end
 
     # Types with fields may override this

data/lib/graphql/directive.rb

@@ -45,7 +45,6 @@ module GraphQL
       INPUT_FIELD_DEFINITION = :INPUT_FIELD_DEFINITION,
     ]
 
-    DEFAULT_DEPRECATION_REASON = 'No longer supported'
     LOCATION_DESCRIPTIONS = {
       QUERY:                    'Location adjacent to a query operation.',
       MUTATION:                 'Location adjacent to a mutation operation.',

data/lib/graphql/directive/deprecated_directive.rb

@@ -1,13 +1,2 @@
 # frozen_string_literal: true
-GraphQL::Directive::DeprecatedDirective = GraphQL::Directive.define do
-  name "deprecated"
-  description "Marks an element of a GraphQL schema as no longer supported."
-  locations([GraphQL::Directive::FIELD_DEFINITION, GraphQL::Directive::ENUM_VALUE])
-
-  reason_description = "Explains why this element was deprecated, usually also including a "\
-    "suggestion for how to access supported similar data. Formatted "\
-    "in [Markdown](https://daringfireball.net/projects/markdown/)."
-
-  argument :reason, GraphQL::STRING_TYPE, reason_description, default_value: GraphQL::Directive::DEFAULT_DEPRECATION_REASON
-  default_directive true
-end
+GraphQL::Directive::DeprecatedDirective = GraphQL::Schema::Directive::Deprecated.graphql_definition

data/lib/graphql/execution/errors.rb

@@ -18,12 +18,7 @@ module GraphQL
     #
     class Errors
       def self.use(schema)
-        schema_class = schema.is_a?(Class) ? schema : schema.target.class
-        schema.tracer(self.new(schema_class))
-      end
-
-      def initialize(schema)
-        @schema = schema
+        schema.tracer(self.new)
       end
 
       def trace(event, data)
@@ -40,12 +35,13 @@ module GraphQL
       def with_error_handling(trace_data)
         yield
       rescue StandardError => err
-        rescues = @schema.rescues
+        ctx = trace_data[:query].context
+        schema = ctx.schema
+        rescues = schema.rescues
         _err_class, handler = rescues.find { |err_class, handler| err.is_a?(err_class) }
         if handler
           obj = trace_data[:object]
           args = trace_data[:arguments]
-          ctx = trace_data[:query].context
           field = trace_data[:field]
           if obj.is_a?(GraphQL::Schema::Object)
             obj = obj.object

data/lib/graphql/execution/interpreter.rb

@@ -17,17 +17,11 @@ module GraphQL
         runtime.final_value
       end
 
-      def self.use(schema_defn)
-        schema_defn.target.interpreter = true
-        # Reach through the legacy objects for the actual class defn
-        schema_class = schema_defn.target.class
-        # This is not good, since both of these are holding state now,
-        # we have to update both :(
-        [schema_class, schema_defn].each do |schema_config|
-          schema_config.query_execution_strategy(GraphQL::Execution::Interpreter)
-          schema_config.mutation_execution_strategy(GraphQL::Execution::Interpreter)
-          schema_config.subscription_execution_strategy(GraphQL::Execution::Interpreter)
-        end
+      def self.use(schema_class)
+        schema_class.interpreter = true
+        schema_class.query_execution_strategy(GraphQL::Execution::Interpreter)
+        schema_class.mutation_execution_strategy(GraphQL::Execution::Interpreter)
+        schema_class.subscription_execution_strategy(GraphQL::Execution::Interpreter)
       end
 
       def self.begin_multiplex(multiplex)

data/lib/graphql/execution/interpreter/runtime.rb

@@ -45,8 +45,7 @@ module GraphQL
         def run_eager
           root_operation = query.selected_operation
           root_op_type = root_operation.operation_type || "query"
-          legacy_root_type = schema.root_type_for_operation(root_op_type)
-          root_type = legacy_root_type.metadata[:type_class] || raise("Invariant: type must be class-based: #{legacy_root_type}")
+          root_type = schema.root_type_for_operation(root_op_type)
           object_proxy = root_type.authorized_new(query.root_value, context)
           object_proxy = schema.sync_lazy(object_proxy)
           if object_proxy.nil?
@@ -86,11 +85,10 @@ module GraphQL
               end
             when GraphQL::Language::Nodes::InlineFragment
               if node.type
-                type_defn = schema.types[node.type.name]
-                type_defn = type_defn.metadata[:type_class]
+                type_defn = schema.get_type(node.type.name)
                 # Faster than .map{}.include?()
                 query.warden.possible_types(type_defn).each do |t|
-                  if t.metadata[:type_class] == owner_type
+                  if t == owner_type
                     gather_selections(owner_object, owner_type, node.selections, selections_by_name)
                     break
                   end
@@ -101,10 +99,9 @@ module GraphQL
               end
             when GraphQL::Language::Nodes::FragmentSpread
               fragment_def = query.fragments[node.name]
-              type_defn = schema.types[fragment_def.type.name]
-              type_defn = type_defn.metadata[:type_class]
-              schema.possible_types(type_defn).each do |t|
-                if t.metadata[:type_class] == owner_type
+              type_defn = schema.get_type(fragment_def.type.name)
+              query.warden.possible_types(type_defn).each do |t|
+                if t == owner_type
                   gather_selections(owner_object, owner_type, fragment_def.selections, selections_by_name)
                   break
                 end
@@ -133,18 +130,18 @@ module GraphQL
             field_defn = @fields_cache[owner_type][field_name] ||= owner_type.get_field(field_name)
             is_introspection = false
             if field_defn.nil?
-              field_defn = if owner_type == schema.query.metadata[:type_class] && (entry_point_field = schema.introspection_system.entry_point(name: field_name))
+              field_defn = if owner_type == schema.query && (entry_point_field = schema.introspection_system.entry_point(name: field_name))
                 is_introspection = true
-                entry_point_field.metadata[:type_class]
+                entry_point_field
               elsif (dynamic_field = schema.introspection_system.dynamic_field(name: field_name))
                 is_introspection = true
-                dynamic_field.metadata[:type_class]
+                dynamic_field
               else
                 raise "Invariant: no field for #{owner_type}.#{field_name}"
               end
             end
 
-            return_type = resolve_if_late_bound_type(field_defn.type)
+            return_type = field_defn.type
 
             next_path = path.dup
             next_path << result_name
@@ -296,7 +293,6 @@ module GraphQL
                 write_in_response(path, nil)
                 nil
               else
-                resolved_type = resolved_type.metadata[:type_class]
                 continue_field(path, value, field, resolved_type, ast_node, next_selections, is_non_null, owner_object, arguments)
               end
             end
@@ -338,8 +334,6 @@ module GraphQL
             response_list
           when "NON_NULL"
             inner_type = type.of_type
-            # For fields like `__schema: __Schema!`
-            inner_type = resolve_if_late_bound_type(inner_type)
             # Don't `set_type_at_path` because we want the static type,
             # we're going to use that to determine whether a `nil` should be propagated or not.
             continue_field(path, value, field, inner_type, ast_node, next_selections, true, owner_object, arguments)
@@ -359,7 +353,7 @@ module GraphQL
           else
             dir_defn = schema.directives.fetch(dir_node.name)
             if !dir_defn.is_a?(Class)
-              dir_defn = dir_defn.metadata[:type_class] || raise("Only class-based directives are supported (not `@#{dir_node.name}`)")
+              dir_defn = dir_defn.type_class || raise("Only class-based directives are supported (not `@#{dir_node.name}`)")
             end
             dir_args = arguments(nil, dir_defn, dir_node)
             dir_defn.resolve(object, dir_args, context) do
@@ -371,7 +365,7 @@ module GraphQL
         # Check {Schema::Directive.include?} for each directive that's present
         def directives_include?(node, graphql_object, parent_type)
           node.directives.each do |dir_node|
-            dir_defn = schema.directives.fetch(dir_node.name).metadata[:type_class] || raise("Only class-based directives are supported (not #{dir_node.name.inspect})")
+            dir_defn = schema.directives.fetch(dir_node.name).type_class || raise("Only class-based directives are supported (not #{dir_node.name.inspect})")
             args = arguments(graphql_object, dir_defn, dir_node)
             if !dir_defn.include?(graphql_object, args, context)
               return false
@@ -380,14 +374,6 @@ module GraphQL
           true
         end
 
-        def resolve_if_late_bound_type(type)
-          if type.is_a?(GraphQL::Schema::LateBoundType)
-            query.warden.get_type(type.name).metadata[:type_class]
-          else
-            type
-          end
-        end
-
         # @param obj [Object] Some user-returned value that may want to be batched
         # @param path [Array<String>]
         # @param field [GraphQL::Schema::Field]
@@ -448,7 +434,7 @@ module GraphQL
             arg_defn = arg_defns[arg_name]
             # Need to distinguish between client-provided `nil`
             # and nothing-at-all
-            is_present, value = arg_to_value(graphql_object, arg_defn.type, arg_value)
+            is_present, value = arg_to_value(graphql_object, arg_defn.type, arg_value, already_arguments: false)
             if is_present
               # This doesn't apply to directives, which are legacy
               # Can remove this when Skip and Include use classes or something.
@@ -460,50 +446,72 @@ module GraphQL
           end
           arg_defns.each do |name, arg_defn|
             if arg_defn.default_value? && !kwarg_arguments.key?(arg_defn.keyword)
-              _is_present, value = arg_to_value(graphql_object, arg_defn.type, arg_defn.default_value)
+              _is_present, value = arg_to_value(graphql_object, arg_defn.type, arg_defn.default_value, already_arguments: false)
               kwarg_arguments[arg_defn.keyword] = value
             end
           end
           kwarg_arguments
         end
 
+        # TODO CAN THIS USE `.coerce_input` ???
+
         # Get a Ruby-ready value from a client query.
         # @param graphql_object [Object] The owner of the field whose argument this is
         # @param arg_type [Class, GraphQL::Schema::NonNull, GraphQL::Schema::List]
         # @param ast_value [GraphQL::Language::Nodes::VariableIdentifier, String, Integer, Float, Boolean]
+        # @param already_arguments [Boolean] if true, don't re-coerce these with `arguments(...)`
         # @return [Array(is_present, value)]
-        def arg_to_value(graphql_object, arg_type, ast_value)
+        def arg_to_value(graphql_object, arg_type, ast_value, already_arguments:)
           if ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
             # If it's not here, it will get added later
             if query.variables.key?(ast_value.name)
-              return true, query.variables[ast_value.name]
+              variable_value = query.variables[ast_value.name]
+              arg_to_value(graphql_object, arg_type, variable_value, already_arguments: true)
             else
               return false, nil
             end
           elsif ast_value.is_a?(GraphQL::Language::Nodes::NullValue)
             return true, nil
           elsif arg_type.is_a?(GraphQL::Schema::NonNull)
-            arg_to_value(graphql_object, arg_type.of_type, ast_value)
+            arg_to_value(graphql_object, arg_type.of_type, ast_value, already_arguments: already_arguments)
           elsif arg_type.is_a?(GraphQL::Schema::List)
-            # Treat a single value like a list
-            arg_value = Array(ast_value)
-            list = []
-            arg_value.map do |inner_v|
-              _present, value = arg_to_value(graphql_object, arg_type.of_type, inner_v)
-              list << value
-            end
-            return true, list
+            if ast_value.nil?
+              return true, nil
+            else
+              # Treat a single value like a list
+              arg_value = Array(ast_value)
+              list = []
+              arg_value.map do |inner_v|
+                _present, value = arg_to_value(graphql_object, arg_type.of_type, inner_v, already_arguments: already_arguments)
+                list << value
+              end
+              return true, list
+            end
           elsif arg_type.is_a?(Class) && arg_type < GraphQL::Schema::InputObject
-            # For these, `prepare` is applied during `#initialize`.
-            # Pass `nil` so it will be skipped in `#arguments`.
-            # What a mess.
-            args = arguments(nil, arg_type, ast_value)
-            # We're not tracking defaults_used, but for our purposes
-            # we compare the value to the default value.
-            return true, arg_type.new(ruby_kwargs: args, context: context, defaults_used: nil)
+            if already_arguments
+              # This came from a variable, already prepared.
+              # But replace `nil` with `{}` like we would for `arg_type`
+              if ast_value.nil?
+                return false, nil
+              else
+                return true, arg_type.new(ruby_kwargs: ast_value, context: context, defaults_used: nil)
+              end
+            else
+              # For these, `prepare` is applied during `#initialize`.
+              # Pass `nil` so it will be skipped in `#arguments`.
+              # What a mess.
+              args = arguments(nil, arg_type, ast_value)
+              return true, arg_type.new(ruby_kwargs: args, context: context, defaults_used: nil)
+            end
           else
-            flat_value = flatten_ast_value(ast_value)
-            return true, arg_type.coerce_input(flat_value, context)
+            flat_value = if already_arguments
+              # It was coerced by variable handling
+              ast_value
+            else
+              v = flatten_ast_value(ast_value)
+              arg_type.coerce_input(v, context)
+            end
+            return true, flat_value
           end
         end