Implicit Resolver for GraphQL Ruby

implicit_resolver_instrumentation.rb

class ImplicitResolverInstrumentation
  def instrument(_type, field)
    implicit_resolver = "Resolvers::#{field.name.camelize}".safe_constantize

    if implicit_resolver && default_or_connection_resolver?(field)
      field.redefine do
        resolve implicit_resolver
      end
    else
      field
    end
  end

  def default_or_connection_resolver?(field)
    field.resolve_proc.class == GraphQL::Field::Resolve::NameResolve
  end
end

implict_resolver_middleware_spec.rb

require 'rails_helper'

RSpec.describe ImplicitResolverInstrumentation do
  let(:instrumentation) { described_class.new }

  class Resolvers::Simple
    def self.call(*)
      'works'
    end
  end

  class Resolvers::Collection
    def self.call(*)
      [1, 2]
    end
  end

  class Resolvers::ConnectionCollection
    def self.call(*)
      [1, 2]
    end
  end

  class Resolvers::Overwritten
    def self.call(*)
      'original'
    end
  end

  let(:schema) do
    query = GraphQL::ObjectType.define do
      name 'Query'
      field :simple, !types.String
      field :collection, !types[types.Int], resolve: ->(_obj, _args, _ctx) { [1, 2] }
      field :overwritten, !types.String, resolve: ->(_obj, _args, _ctx) { 'overwritten' }
      connection :connectionCollection, types.Int.connection_type, resolve: ->(_obj, _args, _ctx) { [1, 2] }
    end

    schema = GraphQL::Schema.define(query: query)
    schema.instrument(:field, described_class.new)
    schema
  end

  let(:result) { schema.execute(query_string) }

  describe 'for a scalar type' do
    let(:query_string) do
      %(
      {
        simple
      }
    )
    end

    it 'returns data in implicit resolver' do
      expect(result).to eq(
        'data' => {
          'simple' => 'works'
        }
      )
    end
  end
  describe 'for collection' do
    let(:query_string) do
      %(
      {
        collection
      }
    )
    end

    it 'returns data in implicit resolver' do
      expect(result).to eq(
        'data' => {
          'collection' => [1, 2]
        }
      )
    end
  end
  describe 'for overwritten resolvers' do
    let(:query_string) do
      %(
      {
        overwritten
      }
    )
    end

    it 'returns data in the explicit resolver' do
      expect(result).to eq(
        'data' => {
          'overwritten' => 'overwritten'
        }
      )
    end
  end
  describe 'for a connection' do
    let(:query_string) do
      %(
      {
        connectionCollection { edges { node } }
      }
    )
    end

    it 'returns data in implicit resolver' do
      expect(result).to eq(
        'data' => {
          'connectionCollection' => {
            'edges' => [
              { 'node' => 1 },
              { 'node' => 2 }
            ]
          }
        }
      )
    end
  end
end