graphql 1.9.0 → 2.1.1

data/lib/graphql/schema/loader.rb

@@ -5,37 +5,50 @@ module GraphQL
     # to make a schema. This schema is missing some important details like
     # `resolve` functions, but it does include the full type system,
     # so you can use it to validate queries.
+    #
+    # @see GraphQL::Schema.from_introspection for a public API
     module Loader
       extend self
 
       # Create schema with the result of an introspection query.
       # @param introspection_result [Hash] A response from {GraphQL::Introspection::INTROSPECTION_QUERY}
-      # @return [GraphQL::Schema] the schema described by `input`
-      # @deprecated Use {GraphQL::Schema.from_introspection} instead
+      # @return [Class] the schema described by `input`
       def load(introspection_result)
         schema = introspection_result.fetch("data").fetch("__schema")
 
         types = {}
-        type_resolver = ->(type) { -> { resolve_type(types, type) } }
+        type_resolver = ->(type) { resolve_type(types, type) }
 
         schema.fetch("types").each do |type|
           next if type.fetch("name").start_with?("__")
           type_object = define_type(type, type_resolver)
-          types[type_object.name] = type_object
+          types[type["name"]] = type_object
         end
 
-        kargs = { orphan_types: types.values, resolve_type: NullResolveType }
-        [:query, :mutation, :subscription].each do |root|
-          type = schema["#{root}Type"]
-          kargs[root] = types.fetch(type.fetch("name")) if type
+        directives = []
+        schema.fetch("directives", []).each do |directive|
+          next if GraphQL::Schema.default_directives.include?(directive.fetch("name"))
+          directives << define_directive(directive, type_resolver)
         end
 
-        Schema.define(**kargs, raise_definition_error: true)
-      end
+        Class.new(GraphQL::Schema) do
+          orphan_types(types.values)
+          directives(directives)
+          description(schema["description"])
+
+          def self.resolve_type(*)
+            raise(GraphQL::RequiredImplementationMissingError, "This schema was loaded from string, so it can't resolve types for objects")
+          end
 
-      NullResolveType = ->(type, obj, ctx) {
-        raise(NotImplementedError, "This schema was loaded from string, so it can't resolve types for objects")
-      }
+          [:query, :mutation, :subscription].each do |root|
+            type = schema["#{root}Type"]
+            if type
+              type_defn = types.fetch(type.fetch("name"))
+              self.public_send(root, type_defn)
+            end
+          end
+        end
+      end
 
       NullScalarCoerce = ->(val, _ctx) { val }
 
@@ -45,13 +58,19 @@ module GraphQL
         def resolve_type(types, type)
           case kind = type.fetch("kind")
           when "ENUM", "INTERFACE", "INPUT_OBJECT", "OBJECT", "SCALAR", "UNION"
-            types.fetch(type.fetch("name"))
+            type_name = type.fetch("name")
+            type = types[type_name] || Schema::BUILT_IN_TYPES[type_name]
+            if type.nil?
+              GraphQL::Schema::LateBoundType.new(type_name)
+            else
+              type
+            end
           when "LIST"
-            ListType.new(of_type: resolve_type(types, type.fetch("ofType")))
+            Schema::List.new(resolve_type(types, type.fetch("ofType")))
           when "NON_NULL"
-            NonNullType.new(of_type: resolve_type(types, type.fetch("ofType")))
+            Schema::NonNull.new(resolve_type(types, type.fetch("ofType")))
           else
-            fail NotImplementedError, "#{kind} not implemented"
+            fail GraphQL::RequiredImplementationMissingError, "#{kind} not implemented"
           end
         end
 
@@ -77,100 +96,130 @@ module GraphQL
         end
 
         def define_type(type, type_resolver)
+          loader = self
           case type.fetch("kind")
           when "ENUM"
-            EnumType.define(
-              name: type["name"],
-              description: type["description"],
-              values: type["enumValues"].map { |enum|
-                EnumType::EnumValue.define(
-                  name: enum["name"],
-                  description: enum["description"],
-                  deprecation_reason: enum["deprecationReason"],
-                  value: enum["name"]
+            Class.new(GraphQL::Schema::Enum) do
+              graphql_name(type["name"])
+              description(type["description"])
+              type["enumValues"].each do |enum_value|
+                value(
+                  enum_value["name"],
+                  description: enum_value["description"],
+                  deprecation_reason: enum_value["deprecationReason"],
                 )
-              })
+              end
+            end
           when "INTERFACE"
-            InterfaceType.define(
-              name: type["name"],
-              description: type["description"],
-              fields: Hash[(type["fields"] || []).map { |field|
-                [field["name"], define_type(field.merge("kind" => "FIELD"), type_resolver)]
-              }]
-            )
+            Module.new do
+              include GraphQL::Schema::Interface
+              graphql_name(type["name"])
+              description(type["description"])
+              loader.build_fields(self, type["fields"] || [], type_resolver)
+            end
           when "INPUT_OBJECT"
-            InputObjectType.define(
-              name: type["name"],
-              description: type["description"],
-              arguments: Hash[type["inputFields"].map { |arg|
-                [arg["name"], define_type(arg.merge("kind" => "ARGUMENT"), type_resolver)]
-              }]
-            )
+            Class.new(GraphQL::Schema::InputObject) do
+              graphql_name(type["name"])
+              description(type["description"])
+              loader.build_arguments(self, type["inputFields"], type_resolver)
+            end
           when "OBJECT"
-            ObjectType.define(
-              name: type["name"],
-              description: type["description"],
-              interfaces: (type["interfaces"] || []).map { |interface|
-                type_resolver.call(interface)
-              },
-              fields: Hash[type["fields"].map { |field|
-                [field["name"], define_type(field.merge("kind" => "FIELD"), type_resolver)]
-              }]
-            )
-          when "FIELD"
-            GraphQL::Field.define(
-              name: type["name"],
-              type: type_resolver.call(type["type"]),
-              description: type["description"],
-              arguments: Hash[type["args"].map { |arg|
-                [arg["name"], define_type(arg.merge("kind" => "ARGUMENT"), type_resolver)]
-              }]
-            )
-          when "ARGUMENT"
-            kwargs = {}
-            if type["defaultValue"]
-              kwargs[:default_value] = begin
-                default_value_str = type["defaultValue"]
-
-                dummy_query_str = "query getStuff($var: InputObj = #{default_value_str}) { __typename }"
-
-                # Returns a `GraphQL::Language::Nodes::Document`:
-                dummy_query_ast = GraphQL.parse(dummy_query_str)
-
-                # Reach into the AST for the default value:
-                input_value_ast = dummy_query_ast.definitions.first.variables.first.default_value
-
-                extract_default_value(default_value_str, input_value_ast)
+            Class.new(GraphQL::Schema::Object) do
+              graphql_name(type["name"])
+              description(type["description"])
+              if type["interfaces"]
+                type["interfaces"].each do |interface_type|
+                  implements(type_resolver.call(interface_type))
+                end
               end
+              loader.build_fields(self, type["fields"], type_resolver)
             end
-
-            GraphQL::Argument.define(
-              name: type["name"],
-              type: type_resolver.call(type["type"]),
-              description: type["description"],
-              **kwargs
-            )
           when "SCALAR"
             type_name = type.fetch("name")
-            if GraphQL::Schema::BUILT_IN_TYPES[type_name]
-              GraphQL::Schema::BUILT_IN_TYPES[type_name]
+            if (builtin = GraphQL::Schema::BUILT_IN_TYPES[type_name])
+              builtin
             else
-              ScalarType.define(
-                name: type["name"],
-                description: type["description"],
-                coerce: NullScalarCoerce,
-              )
+              Class.new(GraphQL::Schema::Scalar) do
+                graphql_name(type["name"])
+                description(type["description"])
+                specified_by_url(type["specifiedByURL"])
+              end
             end
           when "UNION"
-            UnionType.define(
-              name: type["name"],
-              description: type["description"],
-              possible_types: type["possibleTypes"].map { |possible_type|
-                type_resolver.call(possible_type)
-              }
-            )
+            Class.new(GraphQL::Schema::Union) do
+              graphql_name(type["name"])
+              description(type["description"])
+              possible_types(*(type["possibleTypes"].map { |pt| type_resolver.call(pt) }))
+            end
           else
-            fail NotImplementedError, "#{type["kind"]} not implemented"
+            fail GraphQL::RequiredImplementationMissingError, "#{type["kind"]} not implemented"
+          end
+        end
+
+        def define_directive(directive, type_resolver)
+          loader = self
+          Class.new(GraphQL::Schema::Directive) do
+            graphql_name(directive["name"])
+            description(directive["description"])
+            locations(*directive["locations"].map(&:to_sym))
+            repeatable(directive["isRepeatable"])
+            loader.build_arguments(self, directive["args"], type_resolver)
+          end
+        end
+
+        public
+
+        def build_fields(type_defn, fields, type_resolver)
+          loader = self
+          fields.each do |field_hash|
+            unwrapped_field_hash = field_hash
+            while (of_type = unwrapped_field_hash["ofType"])
+              unwrapped_field_hash = of_type
+            end
+            type_name = unwrapped_field_hash["name"]
+
+            type_defn.field(
+              field_hash["name"],
+              type: type_resolver.call(field_hash["type"]),
+              description: field_hash["description"],
+              deprecation_reason: field_hash["deprecationReason"],
+              null: true,
+              camelize: false,
+              connection_extension: nil,
+              connection: type_name.end_with?("Connection"),
+            ) do
+              if field_hash["args"].any?
+                loader.build_arguments(self, field_hash["args"], type_resolver)
+              end
+            end
+          end
+        end
+
+        def build_arguments(arg_owner, args, type_resolver)
+          args.each do |arg|
+            kwargs = {
+              type: type_resolver.call(arg["type"]),
+              description: arg["description"],
+              deprecation_reason: arg["deprecationReason"],
+              required: false,
+              camelize: false,
+            }
+
+            if arg["defaultValue"]
+              default_value_str = arg["defaultValue"]
+
+              dummy_query_str = "query getStuff($var: InputObj = #{default_value_str}) { __typename }"
+
+              # Returns a `GraphQL::Language::Nodes::Document`:
+              dummy_query_ast = GraphQL.parse(dummy_query_str)
+
+              # Reach into the AST for the default value:
+              input_value_ast = dummy_query_ast.definitions.first.variables.first.default_value
+
+              kwargs[:default_value] = extract_default_value(default_value_str, input_value_ast)
+            end
+
+            arg_owner.argument(arg["name"], **kwargs)
           end
         end
       end

data/lib/graphql/schema/member/base_dsl_methods.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/schema/find_inherited_value"
+
 module GraphQL
   class Schema
     class Member
@@ -7,6 +9,8 @@ module GraphQL
       # @api private
       # @see Classes that extend this, eg {GraphQL::Schema::Object}
       module BaseDSLMethods
+        include GraphQL::Schema::FindInheritedValue
+
         # Call this with a new name to override the default name for this schema member; OR
         # call it without an argument to get the name of this schema member
         #
@@ -14,13 +18,11 @@ module GraphQL
         # @param new_name [String]
         # @return [String]
         def graphql_name(new_name = nil)
-          case
-          when new_name
+          if new_name
+            GraphQL::NameValidator.validate!(new_name)
             @graphql_name = new_name
-          when overridden = overridden_graphql_name
-            overridden
           else
-            default_graphql_name
+            @graphql_name ||= default_graphql_name
           end
         end
 
@@ -41,8 +43,27 @@ module GraphQL
         def description(new_description = nil)
           if new_description
             @description = new_description
+          elsif defined?(@description)
+            @description
           else
-            @description || find_inherited_method(:description, nil)
+            @description = nil
+          end
+        end
+
+        # This pushes some configurations _down_ the inheritance tree,
+        # in order to prevent repetitive lookups at runtime.
+        module ConfigurationExtension
+          def inherited(child_class)
+            child_class.introspection(introspection)
+            child_class.description(description)
+            child_class.default_graphql_name = nil
+
+            if defined?(@graphql_name) && @graphql_name && (self.name.nil? || graphql_name != default_graphql_name)
+              child_class.graphql_name(graphql_name)
+            else
+              child_class.graphql_name = nil
+            end
+            super
           end
         end
 
@@ -50,13 +71,15 @@ module GraphQL
         def introspection(new_introspection = nil)
           if !new_introspection.nil?
             @introspection = new_introspection
+          elsif defined?(@introspection)
+            @introspection
           else
-            @introspection || find_inherited_method(:introspection, false)
+            false
           end
         end
 
         def introspection?
-          introspection
+          !!@introspection
         end
 
         # The mutation this type was derived from, if it was derived from a mutation
@@ -64,70 +87,41 @@ module GraphQL
         def mutation(mutation_class = nil)
           if mutation_class
             @mutation = mutation_class
+          elsif defined?(@mutation)
+            @mutation
+          else
+            nil
           end
-          @mutation
-        end
-
-        # @return [GraphQL::BaseType] Convert this type to a legacy-style object.
-        def to_graphql
-          raise NotImplementedError
         end
 
         alias :unwrap :itself
 
-        def overridden_graphql_name
-          @graphql_name || find_inherited_method(:overridden_graphql_name, nil)
-        end
-
         # Creates the default name for a schema member.
         # The default name is the Ruby constant name,
         # without any namespaces and with any `-Type` suffix removed
         def default_graphql_name
           @default_graphql_name ||= begin
-            raise NotImplementedError, 'Anonymous class should declare a `graphql_name`' if name.nil?
-
-            name.split("::").last.sub(/Type\Z/, "")
+            raise GraphQL::RequiredImplementationMissingError, 'Anonymous class should declare a `graphql_name`' if name.nil?
+            g_name = -name.split("::").last
+            g_name.end_with?("Type") ? g_name.sub(/Type\Z/, "") : g_name
           end
         end
 
         def visible?(context)
-          if @mutation
-            @mutation.visible?(context)
-          else
-            true
-          end
+          true
         end
 
-        def accessible?(context)
-          if @mutation
-            @mutation.accessible?(context)
-          else
-            true
-          end
+        def authorized?(object, context)
+          true
         end
 
-        def authorized?(object, context)
-          if @mutation
-            @mutation.authorized?(object, context)
-          else
-            true
-          end
+        def default_relay
+          false
         end
 
-        private
+        protected
 
-        def find_inherited_method(method_name, default_value)
-          if self.is_a?(Class)
-            superclass.respond_to?(method_name) ? superclass.public_send(method_name) : default_value
-          else
-            ancestors[1..-1].each do |ancestor|
-              if ancestor.respond_to?(method_name)
-                return ancestor.public_send(method_name)
-              end
-            end
-            default_value
-          end
-        end
+        attr_writer :default_graphql_name, :graphql_name
       end
     end
   end

data/lib/graphql/schema/member/build_type.rb

@@ -35,18 +35,16 @@ module GraphQL
             else
               maybe_type = constantize(type_expr)
               case maybe_type
-              when GraphQL::BaseType
-                maybe_type
               when Module
                 # This is a way to check that it's the right kind of module:
-                if maybe_type.respond_to?(:graphql_definition)
+                if maybe_type.respond_to?(:kind)
                   maybe_type
                 else
                   raise ArgumentError, "Unexpected class/module found for GraphQL type: #{type_expr} (must be type definition class/module)"
                 end
               end
             end
-          when GraphQL::BaseType, GraphQL::Schema::LateBoundType
+          when GraphQL::Schema::LateBoundType
             type_expr
           when Array
             case type_expr.length
@@ -56,28 +54,32 @@ module GraphQL
               parse_type(type_expr.first, null: false)
             when 2
               inner_type, nullable_option = type_expr
-              if nullable_option.keys != [:null] || nullable_option.values != [true]
+              if nullable_option.keys != [:null] || (nullable_option[:null] != true && nullable_option[:null] != false)
                 raise ArgumentError, LIST_TYPE_ERROR
               end
               list_type = true
-              parse_type(inner_type, null: true)
+              parse_type(inner_type, null: nullable_option[:null])
             else
               raise ArgumentError, LIST_TYPE_ERROR
             end
+          when GraphQL::Schema::NonNull, GraphQL::Schema::List
+            type_expr
           when Module
             # This is a way to check that it's the right kind of module:
-            if type_expr.respond_to?(:graphql_definition)
+            if type_expr.respond_to?(:kind)
               type_expr
             else
-              # Eg `String` => GraphQL::STRING_TYPE
+              # Eg `String` => GraphQL::Types::String
               parse_type(type_expr.name, null: true)
             end
+          when Proc
+            parse_type(type_expr.call, null: true)
           when false
             raise ArgumentError, "Received `false` instead of a type, maybe a `!` should be replaced with `null: true` (for fields) or `required: true` (for arguments)"
           end
 
           if return_type.nil?
-            raise "Unexpected type input: #{type_expr} (#{type_expr.class})"
+            raise "Unexpected type input: #{type_expr.inspect} (#{type_expr.class})"
           end
 
           # Apply list_type first, that way the
@@ -96,7 +98,7 @@ module GraphQL
 
         def to_type_name(something)
           case something
-          when GraphQL::BaseType, GraphQL::Schema::LateBoundType
+          when GraphQL::Schema::LateBoundType
             something.unwrap.name
           when Array
             to_type_name(something.first)
@@ -107,7 +109,14 @@ module GraphQL
               to_type_name(something.name)
             end
           when String
-            something.gsub(/\]\[\!/, "").split("::").last
+            if something.include?("]") ||
+                something.include?("[") ||
+                something.include?("!") ||
+                something.include?("::")
+              something.gsub(/\]\[\!/, "").split("::").last
+            else
+              something
+            end
           when GraphQL::Schema::NonNull, GraphQL::Schema::List
             to_type_name(something.unwrap)
           else
@@ -116,10 +125,12 @@ module GraphQL
         end
 
         def camelize(string)
+          return string if string == '_'
           return string unless string.include?("_")
-          camelized = string.split('_').map(&:capitalize).join
+          camelized = string.split('_').each(&:capitalize!).join
           camelized[0] = camelized[0].downcase
-          if (match_data = string.match(/\A(_+)/))
+          if string.start_with?("_")
+            match_data = string.match(/\A(_+)/)
             camelized = "#{match_data[0]}#{camelized}"
           end
           camelized
@@ -158,10 +169,16 @@ module GraphQL
         end
 
         def underscore(string)
-          string
-            .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2') # URLDecoder -> URL_Decoder
-            .gsub(/([a-z\d])([A-Z])/,'\1_\2')     # someThing -> some_Thing
-            .downcase
+          if string.match?(/\A[a-z_]+\Z/)
+            return string
+          end
+          string2 = string.dup
+
+          string2.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2') # URLDecoder -> URL_Decoder
+          string2.gsub!(/([a-z\d])([A-Z])/,'\1_\2')     # someThing -> some_Thing
+          string2.downcase!
+
+          string2
         end
       end
     end