lighthouse-graphql 0.1.1 → 0.2.0

data/lib/lighthouse/directives/where_conditions_directive.rb

@@ -2,207 +2,243 @@
 
 require 'graphql'
 
-module Lighthouse
-  module GraphQL
-    module Directives
-      class WhereConditionsDirective
-        SQLOPERATOR_TYPE_NAME = 'SQLOperator'.freeze
-        MIXED_SCALAR_NAME = 'Mixed'.freeze
-        PLACEHOLDER_SCALAR_NAME = '_'.freeze
-
-        # Supported operators in the generated GraphQL input type performance.
-        SUPPORTED_OPERATORS = %w[EQ NEQ GT GTE LT LTE IN NIN CONTAINS STARTS_WITH ENDS_WITH IS_NULL IS_NOT_NULL].freeze
-
-        def self.manipulate(sdl)
-          return sdl unless sdl.is_a?(String) && !sdl.empty?
-          begin
-            ast = ::GraphQL::Language::Parser.parse(sdl)
-          rescue => e
-            warn("Lighthouse::GraphQL::Directives::WhereConditionsDirective: parse failed: #{e.class}: #{e.message}")
-            return sdl
-          end
-          existing_defs = ast.definitions.map { |defn| defn.respond_to?(:name) ? defn.name : nil }.compact
-
-          generated = []
-
-          object_types = ast.definitions.select do |defn|
-            defn.is_a?(::GraphQL::Language::Nodes::ObjectTypeDefinition) || defn.is_a?(::GraphQL::Language::Nodes::InterfaceTypeDefinition)
-          end
-
-          object_types.each do |type_def|
-            (type_def.fields || []).each do |field|
-              (field.arguments || []).each do |arg|
-                directive = arg.directives&.find { |d| %w[whereConditions whereHasConditions].include?(d.name) }
-                next unless directive
-
-                if arg.description.nil? || arg.description.empty?
-                  arg.instance_variable_set(
-                    :@description,
-                    directive.name == 'whereHasConditions' ? 'Filter results by related records conditions.' : 'Filter results by field conditions.'
-                  )
-                end
-
-                input_type_name = "#{camelize(type_def.name)}#{camelize(field.name)}#{camelize(arg.name)}WhereConditions"
-                column_enum_name = "#{camelize(type_def.name)}#{camelize(field.name)}#{camelize(arg.name)}Column"
-                relation_input_name = "#{input_type_name}Relation"
-
-                apply_arg_type_replacement(arg, input_type_name)
-
-                # Build input type if needed.
-                unless existing_defs.include?(input_type_name)
-                  generated << build_where_condition_input(input_type_name, column_enum_name, relation_input_name, directive)
-                  existing_defs << input_type_name
-                end
-
-                # Build relation type for HAS support in whereConditions
-                if directive.name == 'whereConditions' && !existing_defs.include?(relation_input_name)
-                  generated << build_where_condition_relation_input(relation_input_name, input_type_name)
-                  existing_defs << relation_input_name
-                end
-
-                # Build column enum type unless columnsEnum is provided.
-                columns_enum = directive_argument_value(directive, 'columnsEnum')
-                columns = directive_argument_value(directive, 'columns')
-                if columns_enum.nil? && columns && !columns.empty? && !existing_defs.include?(column_enum_name)
-                  generated << build_column_enum(column_enum_name, columns)
-                  existing_defs << column_enum_name
-                end
-              end
-            end
-          end
-
-          # Append base utility types only once
-          unless existing_defs.include?(SQLOPERATOR_TYPE_NAME)
-            generated << build_sql_operator_enum
-            existing_defs << SQLOPERATOR_TYPE_NAME
-          end
-
-          unless existing_defs.include?(MIXED_SCALAR_NAME)
-            generated << "scalar #{MIXED_SCALAR_NAME}"
-            existing_defs << MIXED_SCALAR_NAME
-          end
-
-          # Some SDL files use `_` as a placeholder input type, even when no
-          # whereConditions directive is attached (e.g. WIP schema pieces). If we
-          # don't define it, GraphQL-Ruby raises UnresolvedLateBoundTypeError.
-          if contains_placeholder_type?(ast) && !existing_defs.include?(PLACEHOLDER_SCALAR_NAME)
-            generated << "scalar #{PLACEHOLDER_SCALAR_NAME}"
-            existing_defs << PLACEHOLDER_SCALAR_NAME
-          end
-
-          return sdl if generated.empty?
-
-          modified_sdl = ::GraphQL::Language::Printer.new.print(ast)
-          modified_sdl + "\n\n" + generated.join("\n\n")
-        end
-
-        def self.apply_arg_type_replacement(arg, input_type_name)
-          case arg.type
-          when ::GraphQL::Language::Nodes::TypeName
-            if arg.type.name == '_'
-              new_type = ::GraphQL::Language::Nodes::TypeName.new(name: input_type_name)
-              arg.instance_variable_set(:@type, new_type)
-            end
-          when ::GraphQL::Language::Nodes::NonNullType
-            inner = arg.type.of_type
-            if inner.is_a?(::GraphQL::Language::Nodes::TypeName) && inner.name == '_'
-              arg.instance_variable_set(:@type, ::GraphQL::Language::Nodes::NonNullType.new(of_type: ::GraphQL::Language::Nodes::TypeName.new(name: input_type_name)))
-            end
-          end
-        end
-
-        def self.build_where_condition_input(type_name, column_enum_name, relation_type_name, directive)
-          column_type = directive_argument_value(directive, 'columnsEnum') || column_enum_name
-
-          fields = []
-          fields << "  column: #{column_type}"
-          fields << "  operator: #{SQLOPERATOR_TYPE_NAME} = EQ"
-          fields << "  value: #{MIXED_SCALAR_NAME}"
-          fields << "  AND: [#{type_name}!]"
-          fields << "  OR: [#{type_name}!]"
-          fields << "  HAS: #{relation_type_name}" if directive.name == 'whereConditions'
-
-          <<~TEXT.strip
-            input #{type_name} {
-            #{fields.join("\n")}
-            }
-          TEXT
-        end
-
-        def self.build_where_condition_relation_input(type_name, condition_type_name)
-          <<~TEXT.strip
-            input #{type_name} {
-              relation: String!
-              operator: #{SQLOPERATOR_TYPE_NAME} = GTE
-              amount: Int = 1
-              condition: #{condition_type_name}
-            }
-          TEXT
-        end
-
-        def self.build_column_enum(name, columns)
-          values = Array(columns).map do |column|
-            value = column.to_s
-            key = value.gsub(/[^0-9A-Za-z]/, '_').upcase
-            "  #{key}"
-          end.compact.uniq
-
-          <<~TEXT.strip
-            enum #{name} {
-            #{values.join("\n")}
-            }
-          TEXT
-        end
-
-        def self.build_sql_operator_enum
-          values = SUPPORTED_OPERATORS.map { |op| "  #{op}" }
-          <<~TEXT.strip
-            enum #{SQLOPERATOR_TYPE_NAME} {
-            #{values.join("\n")}
-            }
-          TEXT
-        end
-
-        def self.directive_argument_value(directive, name)
-          arg = directive.arguments&.find { |a| a.name == name }
-          return nil unless arg
-
-          # Supports both Babel-style AST and raw Ruby value.
-          value = arg.value.respond_to?(:value) ? arg.value.value : arg.value
-
-          if name == 'columns' && value.is_a?(Array)
-            value.map { |it| it.respond_to?(:value) ? it.value : it }
-          else
-            value
-          end
-        end
-
-        def self.contains_placeholder_type?(document)
-          document.definitions.any? do |defn|
-            next false unless defn.respond_to?(:fields) && defn.fields.respond_to?(:any?)
-            (defn.fields || []).any? do |field|
-              (field.respond_to?(:arguments) ? field.arguments || [] : []).any? { |arg| type_references_placeholder?(arg.type) }
-            end
-          end
-        rescue StandardError
-          false
-        end
-
-        def self.type_references_placeholder?(type_node)
-          case type_node
-          when ::GraphQL::Language::Nodes::TypeName
-            type_node.name == PLACEHOLDER_SCALAR_NAME
-          when ::GraphQL::Language::Nodes::NonNullType, ::GraphQL::Language::Nodes::ListType
-            type_references_placeholder?(type_node.of_type)
-          else
-            false
-          end
-        end
-
-        def self.camelize(value)
-          value.to_s.split(/[_\s]+/).map { |part| part.slice(0,1).upcase + part.slice(1..).to_s }.join
-        end
+class Lighthouse::GraphQL::Directives::WhereConditionsDirective
+  SQLOPERATOR_TYPE_NAME = 'SQLOperator'
+  MIXED_SCALAR_NAME = 'Mixed'
+  PLACEHOLDER_SCALAR_NAME = '_'
+  DEFINITIONS = {
+    'whereConditions' =>
+      'directive @whereConditions(columns: [String!], columnsEnum: String) on ARGUMENT_DEFINITION',
+    'whereHasConditions' =>
+      'directive @whereHasConditions(relation: String, columns: [String!], columnsEnum: String) on ARGUMENT_DEFINITION'
+  }.freeze
+
+  # Default description of an undocumented argument, per directive.
+  ARGUMENT_DESCRIPTIONS = {
+    'whereConditions' => 'Filter results by field conditions.',
+    'whereHasConditions' => 'Filter results by related records conditions.'
+  }.freeze
+
+  # Types whose field arguments may carry the directives.
+  OBJECT_DEFINITIONS = [
+    ::GraphQL::Language::Nodes::ObjectTypeDefinition,
+    ::GraphQL::Language::Nodes::InterfaceTypeDefinition
+  ].freeze
+
+  # Supported operators in the generated GraphQL input type performance.
+  SUPPORTED_OPERATORS = %w[EQ NEQ GT GTE LT LTE IN NIN CONTAINS STARTS_WITH ENDS_WITH IS_NULL IS_NOT_NULL].freeze
+
+  # `definitions` maps every type name to its generated SDL. Names the schema
+  # already declares are seeded with nil, so they are never generated again
+  # and drop out of the output.
+  def self.manipulate(sdl)
+    return sdl unless sdl.is_a?(String) && !sdl.empty?
+
+    ast = parse(sdl)
+    return sdl unless ast
+
+    definitions = ast.definitions.filter_map { |defn| defn.respond_to?(:name) ? defn.name : nil }.index_with(nil)
+    each_where_argument(ast) do |type_def, field, arg, directive|
+      expand_argument(type_def, field, arg, directive, definitions)
+    end
+    define_utility_types(ast, definitions)
+
+    generated = definitions.values.compact
+    return sdl if generated.empty?
+
+    modified_sdl = ::GraphQL::Language::Printer.new.print(ast)
+    "#{modified_sdl}\n\n#{generated.join("\n\n")}"
+  end
+
+  def self.parse(sdl)
+    ::GraphQL::Language::Parser.parse(sdl)
+  rescue StandardError => e
+    warn("Lighthouse::GraphQL::Directives::WhereConditionsDirective: parse failed: #{e.class}: #{e.message}")
+    nil
+  end
+
+  # Yields every object/interface field argument carrying @whereConditions or
+  # @whereHasConditions, along with that directive.
+  def self.each_where_argument(ast)
+    each_field(ast) do |type_def, field|
+      (field.arguments || []).each do |arg|
+        directive = arg.directives&.find { |d| DEFINITIONS.key?(d.name) }
+        yield type_def, field, arg, directive if directive
       end
     end
   end
+
+  def self.each_field(ast)
+    ast.definitions.each do |type_def|
+      next unless OBJECT_DEFINITIONS.any? { |kind| type_def.is_a?(kind) }
+
+      (type_def.fields || []).each { |field| yield type_def, field }
+    end
+  end
+
+  # Points the argument at its generated input type and defines the types it
+  # needs: the conditions input, its HAS relation input and the column enum.
+  def self.expand_argument(type_def, field, arg, directive, definitions)
+    describe_argument(arg, directive)
+
+    prefix = "#{camelize(type_def.name)}#{camelize(field.name)}#{camelize(arg.name)}"
+    input_type_name = "#{prefix}WhereConditions"
+    column_enum_name = "#{prefix}Column"
+    relation_input_name = "#{input_type_name}Relation"
+
+    apply_arg_type_replacement(arg, input_type_name)
+
+    # Build input type if needed.
+    define_once(definitions, input_type_name) do
+      build_where_condition_input(input_type_name, column_enum_name, relation_input_name, directive)
+    end
+
+    # Build relation type for HAS support in whereConditions
+    if directive.name == 'whereConditions'
+      define_once(definitions, relation_input_name) { build_where_condition_relation_input(relation_input_name, input_type_name) }
+    end
+
+    define_column_enum(definitions, column_enum_name, directive)
+  end
+
+  def self.describe_argument(arg, directive)
+    return if arg.description.present?
+
+    arg.instance_variable_set(:@description, ARGUMENT_DESCRIPTIONS.fetch(directive.name))
+  end
+
+  # Build column enum type unless columnsEnum is provided.
+  def self.define_column_enum(definitions, column_enum_name, directive)
+    return unless directive_argument_value(directive, 'columnsEnum').nil?
+
+    columns = directive_argument_value(directive, 'columns')
+    return if Array(columns).empty?
+
+    define_once(definitions, column_enum_name) { build_column_enum(column_enum_name, columns) }
+  end
+
+  def self.define_utility_types(ast, definitions)
+    # Append base utility types only once
+    define_once(definitions, SQLOPERATOR_TYPE_NAME) { build_sql_operator_enum }
+    define_once(definitions, MIXED_SCALAR_NAME) { "scalar #{MIXED_SCALAR_NAME}" }
+
+    # Some SDL files use `_` as a placeholder input type, even when no
+    # whereConditions directive is attached (e.g. WIP schema pieces). If we
+    # don't define it, GraphQL-Ruby raises UnresolvedLateBoundTypeError.
+    return unless contains_placeholder_type?(ast)
+
+    define_once(definitions, PLACEHOLDER_SCALAR_NAME) { "scalar #{PLACEHOLDER_SCALAR_NAME}" }
+  end
+
+  def self.define_once(definitions, name)
+    definitions[name] = yield unless definitions.key?(name)
+  end
+
+  def self.apply_arg_type_replacement(arg, input_type_name)
+    case arg.type
+    when ::GraphQL::Language::Nodes::TypeName
+      arg.instance_variable_set(:@type, ::GraphQL::Language::Nodes::TypeName.new(name: input_type_name)) if arg.type.name == '_'
+    when ::GraphQL::Language::Nodes::NonNullType
+      inner = arg.type.of_type
+      return unless inner.is_a?(::GraphQL::Language::Nodes::TypeName) && inner.name == '_'
+
+      new_type = ::GraphQL::Language::Nodes::NonNullType.new(of_type: ::GraphQL::Language::Nodes::TypeName.new(name: input_type_name))
+      arg.instance_variable_set(:@type, new_type)
+    end
+  end
+
+  def self.build_where_condition_input(type_name, column_enum_name, relation_type_name, directive)
+    column_type = directive_argument_value(directive, 'columnsEnum') || column_enum_name
+
+    fields = []
+    fields << "  column: #{column_type}"
+    fields << "  operator: #{SQLOPERATOR_TYPE_NAME} = EQ"
+    fields << "  value: #{MIXED_SCALAR_NAME}"
+    fields << "  AND: [#{type_name}!]"
+    fields << "  OR: [#{type_name}!]"
+    fields << "  HAS: #{relation_type_name}" if directive.name == 'whereConditions'
+
+    <<~TEXT.strip
+      input #{type_name} {
+      #{fields.join("\n")}
+      }
+    TEXT
+  end
+
+  def self.build_where_condition_relation_input(type_name, condition_type_name)
+    <<~TEXT.strip
+      input #{type_name} {
+        relation: String!
+        operator: #{SQLOPERATOR_TYPE_NAME} = GTE
+        amount: Int = 1
+        condition: #{condition_type_name}
+      }
+    TEXT
+  end
+
+  def self.build_column_enum(name, columns)
+    values = Array(columns).filter_map do |column|
+      value = column.to_s
+      key = value.gsub(/[^0-9A-Za-z]/, '_').upcase
+      "  #{key}"
+    end.uniq
+
+    <<~TEXT.strip
+      enum #{name} {
+      #{values.join("\n")}
+      }
+    TEXT
+  end
+
+  def self.build_sql_operator_enum
+    values = SUPPORTED_OPERATORS.map { |op| "  #{op}" }
+    <<~TEXT.strip
+      enum #{SQLOPERATOR_TYPE_NAME} {
+      #{values.join("\n")}
+      }
+    TEXT
+  end
+
+  def self.directive_argument_value(directive, name)
+    arg = directive.arguments&.find { |a| a.name == name }
+    return nil unless arg
+
+    value = unwrap_value(arg.value)
+    name == 'columns' && value.is_a?(Array) ? value.map { |item| unwrap_value(item) } : value
+  end
+
+  # Supports both Babel-style AST and raw Ruby value.
+  def self.unwrap_value(node)
+    node.respond_to?(:value) ? node.value : node
+  end
+
+  def self.contains_placeholder_type?(document)
+    document.definitions.any? do |defn|
+      next false unless defn.respond_to?(:fields) && defn.fields.respond_to?(:any?)
+
+      (defn.fields || []).any? { |field| placeholder_argument?(field) }
+    end
+  rescue StandardError
+    false
+  end
+
+  def self.placeholder_argument?(field)
+    arguments = (field.respond_to?(:arguments) && field.arguments) || []
+    arguments.any? { |arg| type_references_placeholder?(arg.type) }
+  end
+
+  def self.type_references_placeholder?(type_node)
+    case type_node
+    when ::GraphQL::Language::Nodes::TypeName
+      type_node.name == PLACEHOLDER_SCALAR_NAME
+    when ::GraphQL::Language::Nodes::NonNullType, ::GraphQL::Language::Nodes::ListType
+      type_references_placeholder?(type_node.of_type)
+    else
+      false
+    end
+  end
+
+  def self.camelize(value)
+    value.to_s.split(/[_\s]+/).map { |part| part.slice(0, 1).upcase + part.slice(1..).to_s }.join
+  end
 end

data/lib/lighthouse/errors.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Lighthouse
+  # The schema refers to something that does not exist or breaks a contract —
+  # e.g. a Mutations:: class that is not a GraphQL::Schema::Mutation, or a
+  # missing @validator class. A server bug, so not a client-facing error.
+  class DefinitionError < StandardError; end
+
+  # Raised by the @can* family when the policy denies the ability.
+  class AuthorizationError < ::GraphQL::ExecutionError
+    def initialize(message = 'This action is unauthorized.', **options)
+      super
+    end
+  end
+
+  # Invalid arguments — from a @validator contract or a model's validations.
+  # Mirrors PHP Lighthouse's response: the messages are keyed by argument path
+  # under `extensions.validation`, e.g. { "input.title" => ["Title can't be blank"] }.
+  class ValidationError < ::GraphQL::ExecutionError
+    attr_reader :messages
+
+    def initialize(field_name, messages)
+      @messages = messages
+      super("Validation failed for the field [#{field_name}].", extensions: { 'validation' => messages })
+    end
+  end
+end

data/lib/lighthouse/federation_directives.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Object-level Apollo Federation directives (@key, @extends, @shareable,
+# @inaccessible, @interfaceObject) applied to the types built from SDL, so the
+# Apollo Federation helper can detect entities and add _entities. Only types
+# that know federation (they answer `key`) are touched.
+module Lighthouse::GraphQL::FederationDirectives
+  # Directive => the type's federation method it calls. Each is called only
+  # when the type has it, so a partial federation setup still builds.
+  FLAGS = {
+    'extends' => :extend_type,
+    'shareable' => :shareable,
+    'inaccessible' => :inaccessible,
+    'interfaceObject' => :interface_object
+  }.freeze
+
+  module_function
+
+  def apply(type)
+    return unless type.ast_node && type.respond_to?(:key)
+
+    type.ast_node.directives.each do |dnode|
+      if dnode.name == 'key'
+        apply_key(type, dnode)
+      elsif (flag = FLAGS[dnode.name]) && type.respond_to?(flag)
+        type.public_send(flag)
+      end
+    end
+  end
+
+  def apply_key(type, dnode)
+    arg = dnode.arguments.find { |a| a.name == 'fields' }
+    type.key(fields: arg.value) if arg.respond_to?(:value)
+
+    resolve_references(type)
+  end
+
+  # Setup federation resolve_reference: prefer a custom resolver
+  # registered with ReferenceResolver, but fall back to the base
+  # type's own resolve_reference (e.g. BaseObject's default model
+  # lookup) so direct-model entities resolve without a custom
+  # handler. Capture the inherited implementation before shadowing.
+  def resolve_references(type)
+    default_resolve_reference = type.respond_to?(:resolve_reference) ? type.method(:resolve_reference) : nil
+
+    type.define_singleton_method(:resolve_reference) do |reference, context|
+      resolved = ::Lighthouse::ReferenceResolver.resolve(type.graphql_name, reference, context)
+      next resolved unless resolved.nil?
+
+      default_resolve_reference&.call(reference, context)
+    end
+  end
+end

data/lib/lighthouse/field_resolver_stack.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Install a field's resolvers innermost first (see
+# DirectiveRegistry#resolution_order), so each wrapper decorates the ones
+# before it. Besides its directives, a field gets the conventional
+# Queries::/Mutations:: resolver when it is a root field with no resolving
+# directive, and argument validation when an input type it takes carries
+# @validator. The registry replaces a hardcoded `case dnode.name`: adding a
+# directive is "register a class", not "edit the generator".
+module Lighthouse::GraphQL::FieldResolverStack
+  module_function
+
+  def apply(type, field_def, directives, root_kind)
+    opts = { root_kind: root_kind }
+    steps = directive_steps(type, field_def, directives, opts)
+    steps << convention_step(type, field_def, root_kind) if root_kind && !resolving_directive?(directives)
+    steps << validator_step(type, field_def, opts) if input_validation?(field_def, directives)
+
+    steps.each_with_index.sort_by { |(order, _), index| [order, index] }.each { |(_, step), _| step.call }
+  end
+
+  # [order, step] for every directive the registry has a resolver for.
+  def directive_steps(type, field_def, directives, opts)
+    registry = Lighthouse::DirectiveRegistry.default
+    directives.filter_map do |dnode|
+      resolver_class = registry.resolution_class(dnode.name)
+      next unless resolver_class
+
+      [registry.resolution_order(dnode.name), -> { resolver_class.new(field_def, type, dnode, opts).define_resolver(type) }]
+    end
+  end
+
+  # Whether a directive resolves the field itself (a wrapper only decorates
+  # another resolver), so the field needs no conventional one.
+  def resolving_directive?(directives)
+    registry = Lighthouse::DirectiveRegistry.default
+    directives.any? { |d| registry.resolution_class(d.name) && !registry.wrapper?(d.name) }
+  end
+
+  def convention_step(type, field_def, root_kind)
+    resolver = Lighthouse::GraphQL::DirectiveResolvers::ConventionResolver
+    [0, -> { resolver.new(field_def, type, root_kind).define_resolver(type) }]
+  end
+
+  # An explicit @validator on the field already validates its arguments.
+  def input_validation?(field_def, directives)
+    directives.none? { |d| d.name == 'validator' } &&
+      Lighthouse::GraphQL::DirectiveResolvers::ValidatorDirectiveResolver.input_validators?(field_def)
+  end
+
+  def validator_step(type, field_def, opts)
+    resolver = Lighthouse::GraphQL::DirectiveResolvers::ValidatorDirectiveResolver
+    [Lighthouse::DirectiveRegistry.default.resolution_order('validator'),
+     -> { resolver.new(field_def, type, nil, opts).define_resolver(type) }]
+  end
+end

data/lib/lighthouse/generated_resolvers.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# How the `resolve_field_<name>` singletons that directive resolvers define on
+# a schema's types are found and called at runtime. graphql-ruby resolves an
+# SDL-built schema through `definition_default_resolve` and `resolve_<field>`
+# methods of its own; the hooks here route both to ours.
+module Lighthouse::GraphQL::GeneratedResolvers
+  module_function
+
+  def method_name(field_name)
+    "resolve_field_#{field_name}"
+  end
+
+  def field_name(field)
+    field.respond_to?(:graphql_name) ? field.graphql_name.to_s : field.name.to_s
+  end
+
+  # GraphQL-Ruby's SDL builder also defines `resolve_field_*` methods
+  # internally. Only ours are defined under `lib/lighthouse/`; calling one of
+  # graphql-ruby's would use the wrong arity.
+  def generated?(resolver)
+    source_file, = resolver.source_location
+    source_file&.include?('/lib/lighthouse/')
+  end
+
+  # Generated resolvers take either (obj, args) or (obj, args, ctx).
+  def invoke(resolver, obj, args, ctx)
+    return resolver.call(obj, args) if resolver.parameters.length == 2
+
+    resolver.call(obj, args, ctx)
+  end
+
+  # GraphQL-Ruby caches field resolution procs during schema build; rather
+  # than trying to override per-field `resolve_<field>` methods post-hoc,
+  # we install a single dispatcher here that prefers our generated
+  # `resolve_field_<name>` singletons.
+  def install_dispatcher(schema)
+    return unless schema.respond_to?(:definition_default_resolve=) && schema.respond_to?(:definition_default_resolve)
+
+    previous_default = schema.definition_default_resolve
+    schema.definition_default_resolve = proc do |type, field, obj, arguments, ctx|
+      resolver = generated_resolver(schema, type, field)
+      next invoke(resolver, obj, arguments, ctx) if resolver
+
+      previous_default.call(type, field, obj, arguments, ctx)
+    end
+  end
+
+  # Our generated resolver for `field`, looked up on the schema's own type
+  # (nil when there is none).
+  def generated_resolver(schema, type, field)
+    owner = schema_type(schema, type)
+    name = method_name(field_name(field))
+    return unless owner.respond_to?(name)
+
+    resolver = owner.method(name)
+    resolver if generated?(resolver)
+  end
+
+  def schema_type(schema, type)
+    if type.respond_to?(:graphql_name)
+      schema.types[type.graphql_name]
+    elsif type.respond_to?(:name)
+      schema.types[type.name.to_s]
+    end
+  end
+
+  # GraphQL-Ruby's SDL builder defines `resolve_<field>` methods that call
+  # the schema's `definition_default_resolve`. Override `resolve_<field>`
+  # to delegate to our generated `resolve_field_<field>` when present, so
+  # runtime resolution consistently reaches our directive resolvers.
+  def route_runtime_resolver(type, field_def)
+    generated = method_name(field_def.name)
+    return unless type.respond_to?(generated)
+
+    type.define_singleton_method("resolve_#{field_def.name}") do |obj, arguments, ctx|
+      public_send(generated, obj, arguments, ctx)
+    end
+  rescue StandardError
+    # ignore override failures
+  end
+end

data/lib/lighthouse/graphql/version.rb

@@ -2,6 +2,6 @@
 
 module Lighthouse
   module GraphQL
-    VERSION = '0.1.1'
+    VERSION = '0.2.0'
   end
 end