graphql 1.13.24 → 2.5.11

data/lib/graphql/schema/introspection_system.rb

@@ -25,10 +25,10 @@ module GraphQL
           load_constant(:DirectiveLocationEnum)
         ]
         @types = {}
-        @possible_types = {}
+        @possible_types = {}.compare_by_identity
         type_defns.each do |t|
           @types[t.graphql_name] = t
-          @possible_types[t.graphql_name] = [t]
+          @possible_types[t] = [t]
         end
         @entry_point_fields =
           if schema.disable_introspection_entry_points?
@@ -39,7 +39,9 @@ module GraphQL
             entry_point_fields.delete('__type') if schema.disable_type_introspection_entry_point?
             entry_point_fields
           end
+        @entry_point_fields.each { |k, v| v.dynamic_introspection = true }
         @dynamic_fields = get_fields_from_class(class_sym: :DynamicFields)
+        @dynamic_fields.each { |k, v| v.dynamic_introspection = true }
       end
 
       def entry_points
@@ -67,7 +69,7 @@ module GraphQL
       def resolve_late_bindings
         @types.each do |name, t|
           if t.kind.fields?
-            t.fields.each do |_name, field_defn|
+            t.all_field_definitions.each do |field_defn|
               field_defn.type = resolve_late_binding(field_defn.type)
             end
           end
@@ -88,10 +90,11 @@ module GraphQL
       def resolve_late_binding(late_bound_type)
         case late_bound_type
         when GraphQL::Schema::LateBoundType
-          @schema.get_type(late_bound_type.name)
-        when GraphQL::Schema::List, GraphQL::ListType
+          type_name = late_bound_type.name
+          @types[type_name] || @schema.get_type(type_name)
+        when GraphQL::Schema::List
           resolve_late_binding(late_bound_type.of_type).to_list_type
-        when GraphQL::Schema::NonNull, GraphQL::NonNullType
+        when GraphQL::Schema::NonNull
           resolve_late_binding(late_bound_type.of_type).to_non_null_type
         when Module
           # It's a normal type -- no change required
@@ -103,12 +106,7 @@ module GraphQL
 
       def load_constant(class_name)
         const = @custom_namespace.const_get(class_name)
-        if @class_based
-          dup_type_class(const)
-        else
-          # Use `.to_graphql` to get a freshly-made version, not shared between schemas
-          const.deprecated_to_graphql
-        end
+        dup_type_class(const)
       rescue NameError
         # Dup the built-in so that the cached fields aren't shared
         dup_type_class(@built_in_namespace.const_get(class_name))
@@ -116,19 +114,7 @@ module GraphQL
 
       def get_fields_from_class(class_sym:)
         object_type_defn = load_constant(class_sym)
-
-        if object_type_defn.is_a?(Module)
-          object_type_defn.fields
-        else
-          extracted_field_defns = {}
-          object_class = object_type_defn.metadata[:type_class]
-          object_type_defn.all_fields.each do |field_defn|
-            inner_resolve = field_defn.resolve_proc
-            resolve_with_instantiate = PerFieldProxyResolve.new(object_class: object_class, inner_resolve: inner_resolve)
-            extracted_field_defns[field_defn.name] = field_defn.redefine(resolve: resolve_with_instantiate)
-          end
-          extracted_field_defns
-        end
+        object_type_defn.fields
       end
 
       # This is probably not 100% robust -- but it has to be good enough to avoid modifying the built-in introspection types
@@ -160,7 +146,7 @@ module GraphQL
           if obj.is_a?(GraphQL::Schema::Object)
             obj = obj.object
           end
-          wrapped_object = @object_class.authorized_new(obj, query_ctx)
+          wrapped_object = @object_class.wrap(obj, query_ctx)
           @inner_resolve.call(wrapped_object, args, ctx)
         end
       end

data/lib/graphql/schema/late_bound_type.rb

@@ -9,6 +9,8 @@ module GraphQL
       alias :graphql_name :name
       def initialize(local_name)
         @name = local_name
+        @to_non_null_type = nil
+        @to_list_type = nil
       end
 
       def unwrap
@@ -16,17 +18,25 @@ module GraphQL
       end
 
       def to_non_null_type
-        @to_non_null_type ||= GraphQL::NonNullType.new(of_type: self)
+        @to_non_null_type ||= GraphQL::Schema::NonNull.new(self)
       end
 
       def to_list_type
-        @to_list_type ||= GraphQL::ListType.new(of_type: self)
+        @to_list_type ||= GraphQL::Schema::List.new(self)
+      end
+
+      def to_type_signature
+        name
       end
 
       def inspect
         "#<LateBoundType @name=#{name}>"
       end
 
+      def non_null?
+        false
+      end
+
       alias :to_s :inspect
     end
   end

data/lib/graphql/schema/list.rb

@@ -4,16 +4,10 @@ module GraphQL
   class Schema
     # Represents a list type in the schema.
     # Wraps a {Schema::Member} as a list type.
-    # @see {Schema::Member::TypeSystemHelpers#to_list_type}
+    # @see Schema::Member::TypeSystemHelpers#to_list_type Create a list type from another GraphQL type
     class List < GraphQL::Schema::Wrapper
       include Schema::Member::ValidatesInput
 
-      prepend Schema::Member::CachedGraphQLDefinition::DeprecatedToGraphQL
-
-      def to_graphql
-        @of_type.graphql_definition(silence_deprecation_warning: true).to_list_type
-      end
-
       # @return [GraphQL::TypeKinds::LIST]
       def kind
         GraphQL::TypeKinds::LIST
@@ -58,7 +52,7 @@ module GraphQL
           unless item_result.valid?
             if max_errors
               if max_errors == 0
-                add_max_errros_reached_message(result)
+                add_max_errors_reached_message(result)
                 break
               end
 
@@ -82,7 +76,7 @@ module GraphQL
         end
       end
 
-      def add_max_errros_reached_message(result)
+      def add_max_errors_reached_message(result)
         message = "Too many errors processing list variable, max validation error limit reached. Execution aborted"
         item_result = GraphQL::Query::InputValidationResult.from_problem(message)
         result.merge_result!(nil, item_result)

data/lib/graphql/schema/loader.rb

@@ -32,7 +32,8 @@ module GraphQL
         end
 
         Class.new(GraphQL::Schema) do
-          orphan_types(types.values)
+          add_type_and_traverse(types.values, root: false)
+          orphan_types(types.values.select { |t| t.kind.object? })
           directives(directives)
           description(schema["description"])
 
@@ -142,7 +143,7 @@ module GraphQL
               Class.new(GraphQL::Schema::Scalar) do
                 graphql_name(type["name"])
                 description(type["description"])
-                specified_by_url(type["specifiedByUrl"])
+                specified_by_url(type["specifiedByURL"])
               end
             end
           when "UNION"
@@ -176,7 +177,6 @@ module GraphQL
             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"],
@@ -186,9 +186,8 @@ module GraphQL
               null: true,
               camelize: false,
               connection_extension: nil,
-              connection: type_name.end_with?("Connection"),
             ) do
-              if field_hash["args"].any?
+              if !field_hash["args"].empty?
                 loader.build_arguments(self, field_hash["args"], type_resolver)
               end
             end
@@ -202,7 +201,6 @@ module GraphQL
               description: arg["description"],
               deprecation_reason: arg["deprecationReason"],
               required: false,
-              method_access: false,
               camelize: false,
             }
 

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

@@ -22,14 +22,10 @@ module GraphQL
             GraphQL::NameValidator.validate!(new_name)
             @graphql_name = new_name
           else
-            overridden_graphql_name || default_graphql_name
+            @graphql_name ||= default_graphql_name
           end
         end
 
-        def overridden_graphql_name
-          defined?(@graphql_name) ? @graphql_name : nil
-        end
-
         # Just a convenience method to point out that people should use graphql_name instead
         def name(new_name = nil)
           return super() if new_name.nil?
@@ -49,6 +45,20 @@ module GraphQL
             @description = new_description
           elsif defined?(@description)
             @description
+          else
+            @description = nil
+          end
+        end
+
+        # Call this method to provide a new comment; OR
+        # call it without an argument to get the comment
+        # @param new_comment [String]
+        # @return [String, nil]
+        def comment(new_comment = NOT_CONFIGURED)
+          if !NOT_CONFIGURED.equal?(new_comment)
+            @comment = new_comment
+          elsif defined?(@comment)
+            @comment
           else
             nil
           end
@@ -60,8 +70,13 @@ module GraphQL
           def inherited(child_class)
             child_class.introspection(introspection)
             child_class.description(description)
-            if overridden_graphql_name
-              child_class.graphql_name(overridden_graphql_name)
+            child_class.comment(nil)
+            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
@@ -79,7 +94,7 @@ module GraphQL
         end
 
         def introspection?
-          introspection
+          !!@introspection
         end
 
         # The mutation this type was derived from, if it was derived from a mutation
@@ -94,11 +109,6 @@ module GraphQL
           end
         end
 
-        # @return [GraphQL::BaseType] Convert this type to a legacy-style object.
-        def to_graphql
-          raise GraphQL::RequiredImplementationMissingError
-        end
-
         alias :unwrap :itself
 
         # Creates the default name for a schema member.
@@ -107,8 +117,8 @@ module GraphQL
         def default_graphql_name
           @default_graphql_name ||= begin
             raise GraphQL::RequiredImplementationMissingError, 'Anonymous class should declare a `graphql_name`' if name.nil?
-
-            -name.split("::").last.sub(/Type\Z/, "")
+            g_name = -name.split("::").last
+            g_name.end_with?("Type") ? g_name.sub(/Type\Z/, "") : g_name
           end
         end
 
@@ -116,13 +126,17 @@ module GraphQL
           true
         end
 
-        def accessible?(context)
+        def authorized?(object, context)
           true
         end
 
-        def authorized?(object, context)
-          true
+        def default_relay
+          false
         end
+
+        protected
+
+        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
@@ -68,7 +66,7 @@ module GraphQL
             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::Types::String
@@ -100,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)
@@ -111,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
@@ -122,9 +127,10 @@ module GraphQL
         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