graphql-doctor 0.1.0

data/lib/graphql/doctor/runtime/reflector.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+require "rubygems/version"
+
+module GraphQL
+  module Doctor
+    module Runtime
+      class Reflector
+        OWNER_PREPARE_VERSION = Gem::Version.new("2.1.8")
+
+        def initialize(schema, source_index: nil, abstract_classes: [])
+          @schema = schema
+          @source_index = source_index
+          @abstract_classes = abstract_classes
+        end
+
+        def call
+          {
+            "version" => 1,
+            "graphql_ruby_version" => GraphQL::VERSION,
+            "schema" => @schema.name,
+            "types" => reflected_types,
+            "orphan_members" => orphan_members
+          }
+        end
+
+        private
+
+        def reflected_types
+          @reflected_types ||= @schema.types.values.filter_map do |type|
+            next unless reflectable_type?(type)
+
+            fields = (type.respond_to?(:fields) ? type.fields.values : []).filter_map do |field|
+              reflect_field(field) if owned_field?(field, type)
+            end
+            next if fields.empty? && built_in?(type)
+
+            {
+              "name" => type.graphql_name,
+              "kind" => type_kind(type),
+              "ruby_class" => type.name,
+              "interfaces" => type.respond_to?(:interfaces) ? type.interfaces.map(&:name) : [],
+              "source_location" => constant_source_location(type.name),
+              "fields" => fields
+            }
+          end
+        end
+
+        def reflect_field(field)
+          owner = field.owner
+          return if owner.name.nil?
+
+          resolver_owner = field.resolver || owner
+          resolver_method = field.resolver ? field.resolver.resolve_method : field.resolver_method
+          source_options = source_field_options(owner.name, field.graphql_name)
+          object_class = underlying_object_class(owner)
+          {
+            "graphql_name" => field.graphql_name,
+            "owner" => owner.name,
+            "method_sym" => field.method_sym.to_s,
+            "resolver_method" => resolver_method.to_s,
+            "hash_key" => json_value(configured_hash_key(member_value(field, :hash_key)) || source_options[:hash_key]),
+            "dig_keys" => json_value(member_value(field, :dig_keys) || source_options[:dig]),
+            "resolver_class" => field.resolver&.name,
+            "type" => field.type.to_type_signature,
+            "extras" => field.extras.map(&:to_s),
+            "extensions" => field.extensions.map { |extension| extension.class.name },
+            **method_metadata(resolver_owner, resolver_method, field.resolver),
+            "underlying_object_class" => object_class&.name,
+            "underlying_method_defined" => object_class&.public_method_defined?(field.method_sym),
+            "arguments" => field_arguments(field).map { |argument| reflect_argument(argument, field) }
+          }
+        end
+
+        def reflect_argument(argument, field)
+          prepare = prepare_value(argument.prepare)
+          method, dispatch = prepare_method(prepare, field)
+          {
+            "graphql_name" => argument.graphql_name,
+            "keyword" => argument.keyword.to_s,
+            "type" => argument.type.to_type_signature,
+            "non_null" => argument.type.non_null?,
+            "required" => argument.type.non_null? || required_nullable?(argument),
+            "has_default" => argument.default_value?,
+            "default_value" => argument.default_value? ? json_value(argument.default_value) : nil,
+            "loads" => constant_name(argument.loads),
+            "as" => member_value(argument, :as)&.to_s,
+            "prepare" => prepare,
+            "prepare_source_location" => method&.source_location,
+            "prepare_method_valid" => method && prepare_method_valid?(method, dispatch == "resolver" ? 2 : 1),
+            "prepare_method_dispatch" => dispatch
+          }
+        end
+
+        def prepare_method(prepare, field)
+          return [nil, nil] unless prepare
+
+          object_method = public_instance_method(field.owner, prepare)
+          return [object_method, "object"] if object_method
+          return [nil, nil] unless field.resolver && Gem::Version.new(GraphQL::VERSION) >= OWNER_PREPARE_VERSION
+
+          [field.resolver.public_method(prepare), "resolver"]
+        rescue NameError
+          [nil, nil]
+        end
+
+        def required_nullable?(argument)
+          owner = argument.owner
+          return false unless owner.respond_to?(:validators)
+
+          owner.validators.any? do |validator|
+            next false unless validator.is_a?(GraphQL::Schema::Validator::RequiredValidator)
+
+            names = Array(validator.instance_variable_get(:@one_of))
+            names.one? && GraphQL::Schema::Member::BuildType.camelize(names.first.to_s) == argument.graphql_name
+          end
+        end
+
+        def public_instance_method(owner, name)
+          owner.public_instance_method(name)
+        rescue NameError
+          nil
+        end
+
+        def prepare_method_valid?(method, positional_count)
+          parameters = method.parameters
+          required = parameters.count { |kind, _name| kind == :req }
+          optional = parameters.count { |kind, _name| kind == :opt }
+          accepts_rest = parameters.any? { |kind, _name| kind == :rest }
+          required_keywords = parameters.any? { |kind, _name| kind == :keyreq }
+          maximum_valid = accepts_rest || positional_count <= required + optional
+          !required_keywords && required <= positional_count && maximum_valid
+        end
+
+        def callback_methods(resolver)
+          return {} unless resolver
+
+          %i[ready? authorized?].to_h { |name| [name.to_s, instance_method(resolver, name)] }.compact
+        end
+
+        def method_metadata(owner, name, resolver_class)
+          resolver = instance_method(owner, name)
+          callbacks = callback_methods(resolver_class)
+          {
+            "resolver_source_location" => resolver&.source_location,
+            "resolver_signature" => method_signature(owner, name, resolver),
+            "callback_source_locations" => callbacks.transform_values(&:source_location),
+            "callback_signatures" => callbacks.transform_values do |method|
+              method_signature(resolver_class, method.name, method)
+            end
+          }
+        end
+
+        def method_signature(owner, name, method)
+          return unless method
+
+          parameters = method.parameters
+          {
+            "visibility" => method_visibility(owner, name).to_s,
+            "required_keywords" => parameters.filter_map { |kind, key| key.to_s if kind == :keyreq },
+            "optional_keywords" => parameters.filter_map { |kind, key| key.to_s if kind == :key },
+            "accepts_keyword_rest" => parameters.any? { |kind, _key| kind == :keyrest },
+            "required_positionals" => parameters.count { |kind, _key| kind == :req },
+            "optional_positionals" => parameters.count { |kind, _key| kind == :opt },
+            "accepts_positional_rest" => parameters.any? { |kind, _key| kind == :rest }
+          }
+        end
+
+        def method_visibility(owner, name)
+          return :public if owner.public_method_defined?(name)
+          return :protected if owner.protected_method_defined?(name)
+
+          :private
+        end
+
+        def field_arguments(field)
+          resolver = field.resolver
+          if defined?(GraphQL::Schema::RelayClassicMutation) && resolver && resolver < GraphQL::Schema::RelayClassicMutation
+            return resolver.all_argument_definitions.reject { |argument| argument.keyword == :client_mutation_id }
+          end
+
+          field.arguments.values
+        end
+
+        def orphan_members
+          return [] unless @source_index
+
+          referenced = reflected_types.flat_map do |type|
+            type["fields"].filter_map { |field| field["resolver_class"] }
+          end
+          candidates = @source_index.types.filter_map do |definition|
+            next if definition.confidence == :dynamic
+            next unless resolver_namespace?(definition.owner)
+            next unless resolver_class?(definition.owner)
+
+            definition.owner
+          end
+          candidates = candidates.uniq
+          candidates.reject! { |name| abstract_with_subclass?(name, candidates) }
+          candidates - referenced.uniq
+        end
+
+        def resolver_class?(name)
+          constant = constantize(name)
+          constant < GraphQL::Schema::Resolver || constant < GraphQL::Schema::Mutation
+        rescue NameError
+          false
+        end
+
+        def resolver_namespace?(name)
+          name.match?(/(?:\A|::)(?:Mutations|Resolvers)::/)
+        end
+
+        def abstract_with_subclass?(name, candidates)
+          return false unless @abstract_classes.include?(name)
+
+          parent = constantize(name)
+          candidates.any? { |candidate| candidate != name && constantize(candidate) < parent }
+        rescue NameError
+          false
+        end
+
+        def constantize(name)
+          name.split("::").reduce(Object) { |namespace, part| namespace.const_get(part, false) }
+        end
+
+        def instance_method(owner, method_name)
+          owner.instance_method(method_name)
+        rescue NameError
+          nil
+        end
+
+        def configured_hash_key(value)
+          value if value.is_a?(String) || value.is_a?(Symbol)
+        end
+
+        def json_value(value)
+          case value
+          when Hash then value.to_h { |key, item| [key.to_s, json_value(item)] }
+          when Array then value.map { |item| json_value(item) }
+          when Float then value.finite? ? value : value.to_s
+          when String, Integer, TrueClass, FalseClass, NilClass then value
+          else value.to_s
+          end
+        end
+
+        def source_field_options(owner, graphql_name)
+          return {} unless @source_index
+
+          field = @source_index.fields.find do |definition|
+            definition.owner == owner && definition.graphql_name == graphql_name
+          end
+          field ? field.options : {}
+        end
+
+        def member_value(member, name)
+          return member.public_send(name) if member.respond_to?(name)
+
+          member.instance_variable_get("@#{name}")
+        end
+
+        def constant_source_location(name)
+          return unless name
+
+          Object.const_source_location(name)
+        rescue NameError
+          nil
+        end
+
+        def constant_name(value)
+          value.respond_to?(:name) ? value.name : value&.to_s
+        end
+
+        def underlying_object_class(owner)
+          return unless owner.is_a?(Class) && owner < GraphQL::Schema::Object && owner.respond_to?(:object_class)
+
+          object_class = owner.object_class
+          object_class if object_class.is_a?(Class) && object_class.name && !(object_class <= Hash)
+        rescue StandardError
+          nil
+        end
+
+        def prepare_value(value)
+          value.is_a?(Symbol) ? value.to_s : (value if value.is_a?(String))
+        end
+
+        def built_in?(type)
+          type.name&.start_with?("GraphQL::")
+        end
+
+        def type_kind(type)
+          type.kind.name
+        rescue NoMethodError
+          type.class.name.split("::").last.upcase
+        end
+
+        def supported_type?(type)
+          %w[OBJECT INTERFACE INPUT_OBJECT UNION ENUM].include?(type_kind(type))
+        end
+
+        def reflectable_type?(type)
+          supported_type?(type) && !type.graphql_name.start_with?("__")
+        end
+
+        def owned_field?(field, type)
+          return true if field.owner == type
+
+          field.owner < GraphQL::Schema::Mutation && !built_in?(field.owner)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/doctor/runtime/schema_loader.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Doctor
+    module Runtime
+      class SchemaLoader
+        def self.load(config, root: Dir.pwd)
+          boot_environment(config["require"], root)
+
+          name = config["schema"]
+          raise Error, "Configuration key `schema` is required" unless name && !name.strip.empty?
+
+          schema = resolve_schema(name)
+          raise Error, "Configured schema `#{name}` is not a GraphQL::Schema subclass" unless graphql_schema?(schema)
+
+          schema
+        rescue StandardError, LoadError, SyntaxError => e
+          raise Error, "GQLD101: Failed to boot schema: #{e.message}"
+        end
+
+        def self.boot_environment(require_path, root)
+          require File.expand_path(require_path, root) if require_path && !require_path.empty?
+          Rails.application.eager_load! if defined?(Rails.application) && Rails.application.respond_to?(:eager_load!)
+        end
+
+        def self.resolve_schema(name)
+          name.split("::").reject(&:empty?).reduce(Object) do |namespace, constant|
+            namespace.const_get(constant, false)
+          end
+        end
+
+        def self.graphql_schema?(schema)
+          defined?(GraphQL::Schema) && schema.is_a?(Class) && schema < GraphQL::Schema
+        end
+
+        private_class_method :boot_environment, :resolve_schema, :graphql_schema?
+      end
+    end
+  end
+end