graphql 1.7.6 → 1.8.0

data/lib/graphql/schema/interface.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    module Interface
+      include GraphQL::Schema::Member::GraphQLTypeNames
+      module DefinitionMethods
+        include GraphQL::Schema::Member::CachedGraphQLDefinition
+        include GraphQL::Relay::TypeExtensions
+        include GraphQL::Schema::Member::BaseDSLMethods
+        include GraphQL::Schema::Member::TypeSystemHelpers
+        include GraphQL::Schema::Member::HasFields
+
+        # Methods defined in this block will be:
+        # - Added as class methods to this interface
+        # - Added as class methods to all child interfaces
+        def definition_methods(&block)
+          self::DefinitionMethods.module_eval(&block)
+        end
+
+        # Here's the tricky part. Make sure behavior keeps making its way down the inheritance chain.
+        def included(child_class)
+          if !child_class.is_a?(Class)
+            # In this case, it's been included into another interface.
+            # This is how interface inheritance is implemented
+
+            # Use an instance variable to tell whether it's been included previously or not;
+            # You can't use constant detection because constants are brought into scope
+            # by `include`, which has already happened at this point.
+            if !child_class.instance_variable_defined?(:@_definition_methods)
+              defn_methods_module = Module.new
+              child_class.instance_variable_set(:@_definition_methods, defn_methods_module)
+              child_class.const_set(:DefinitionMethods, defn_methods_module)
+              child_class.extend(child_class::DefinitionMethods)
+            end
+
+            # We need this before we can call `own_interfaces`
+            child_class.extend(Schema::Interface::DefinitionMethods)
+
+            child_class.own_interfaces << self
+            child_class.interfaces.each do |interface_defn|
+              child_class.extend(interface_defn::DefinitionMethods)
+            end
+          elsif child_class < GraphQL::Schema::Object
+            # This is being included into an object type, make sure it's using `implements(...)`
+            backtrace_line = caller(0, 10).find { |line| line.include?("schema/object.rb") && line.include?("in `implements'")}
+            if !backtrace_line
+              raise "Attach interfaces using `implements(#{self})`, not `include(#{self})`"
+            end
+          end
+
+          super
+        end
+
+        def orphan_types(*types)
+          if types.any?
+            @orphan_types = types
+          else
+            all_orphan_types = @orphan_types || []
+            all_orphan_types += super if defined?(super)
+            all_orphan_types.uniq
+          end
+        end
+
+        def to_graphql
+          type_defn = GraphQL::InterfaceType.new
+          type_defn.name = graphql_name
+          type_defn.description = description
+          type_defn.orphan_types = orphan_types
+          fields.each do |field_name, field_inst|
+            field_defn = field_inst.graphql_definition
+            type_defn.fields[field_defn.name] = field_defn
+          end
+          type_defn.metadata[:type_class] = self
+          if respond_to?(:resolve_type)
+            type_defn.resolve_type = method(:resolve_type)
+          end
+          type_defn
+        end
+
+        def kind
+          GraphQL::TypeKinds::INTERFACE
+        end
+
+        protected
+
+        def own_interfaces
+          @own_interfaces ||= []
+        end
+
+        def interfaces
+          own_interfaces + (own_interfaces.map { |i| i.own_interfaces }).flatten
+        end
+      end
+
+      # Extend this _after_ `DefinitionMethods` is defined, so it will be used
+      extend GraphQL::Schema::Member::AcceptsDefinition
+
+      extend DefinitionMethods
+
+      def unwrap
+        self
+      end
+    end
+  end
+end

data/lib/graphql/schema/introspection_system.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class IntrospectionSystem
+      attr_reader :schema_type, :type_type, :typename_field
+
+      def initialize(schema)
+        @schema = schema
+        @built_in_namespace = GraphQL::Introspection
+        @custom_namespace = schema.introspection_namespace || @built_in_namespace
+
+        # Use to-graphql to avoid sharing with any previous instantiations
+        @schema_type = load_constant(:SchemaType).to_graphql
+        @type_type = load_constant(:TypeType).to_graphql
+        @field_type = load_constant(:FieldType).to_graphql
+        @directive_type = load_constant(:DirectiveType).to_graphql
+        @enum_value_type = load_constant(:EnumValueType).to_graphql
+        @input_value_type = load_constant(:InputValueType).to_graphql
+        @type_kind_enum = load_constant(:TypeKindEnum).to_graphql
+        @directive_location_enum = load_constant(:DirectiveLocationEnum).to_graphql
+        @entry_point_fields = get_fields_from_class(class_sym: :EntryPoints)
+        @dynamic_fields = get_fields_from_class(class_sym: :DynamicFields)
+      end
+
+      def object_types
+        [
+          @schema_type,
+          @type_type,
+          @field_type,
+          @directive_type,
+          @enum_value_type,
+          @input_value_type,
+          @type_kind_enum,
+          @directive_location_enum,
+        ]
+      end
+
+      def entry_points
+        @entry_point_fields.values
+      end
+
+      def entry_point(name:)
+        @entry_point_fields[name]
+      end
+
+      def dynamic_fields
+        @dynamic_fields.values
+      end
+
+      def dynamic_field(name:)
+        @dynamic_fields[name]
+      end
+
+      private
+
+      def load_constant(class_name)
+        @custom_namespace.const_get(class_name)
+      rescue NameError
+        # Dup the built-in so that the cached fields aren't shared
+        @built_in_namespace.const_get(class_name)
+      end
+
+      def get_fields_from_class(class_sym:)
+        object_class = load_constant(class_sym)
+        object_type_defn = object_class.to_graphql
+        extracted_field_defns = {}
+        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
+
+      class PerFieldProxyResolve
+        def initialize(object_class:, inner_resolve:)
+          @object_class = object_class
+          @inner_resolve = inner_resolve
+        end
+
+        def call(obj, args, ctx)
+          query_ctx = ctx.query.context
+          # Remove the QueryType wrapper
+          if obj.is_a?(GraphQL::Schema::Object)
+            obj = obj.object
+          end
+          wrapped_object = @object_class.new(obj, query_ctx)
+          @inner_resolve.call(wrapped_object, args, ctx)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/late_bound_type.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    # A stand-in for a type which will be resolved in a given schema, by name.
+    # TODO: support argument types too, make this a public API somehow
+    # @api Private
+    class LateBoundType
+      attr_reader :name
+      def initialize(local_name)
+        @name = local_name
+      end
+
+      def unwrap
+        self
+      end
+
+      def to_non_null_type
+        GraphQL::NonNullType.new(of_type: self)
+      end
+
+      def to_list_type
+        GraphQL::ListType.new(of_type: self)
+      end
+
+      def inspect
+        "#<LateBoundType @name=#{name}>"
+      end
+
+      alias :to_s :inspect
+    end
+  end
+end

data/lib/graphql/schema/list.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+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}
+    class List
+      include GraphQL::Schema::Member::CachedGraphQLDefinition
+      include GraphQL::Schema::Member::TypeSystemHelpers
+
+      # @return [Class, Module] The inner type of this list, the type of which one or more objects may be present.
+      attr_reader :of_type
+
+      def initialize(of_type)
+        @of_type = of_type
+      end
+
+      def to_graphql
+        @of_type.graphql_definition.to_list_type
+      end
+
+      def kind
+        GraphQL::TypeKinds::LIST
+      end
+
+      def unwrap
+        @of_type.unwrap
+      end
+    end
+  end
+end

data/lib/graphql/schema/loader.rb

@@ -97,7 +97,7 @@ module GraphQL
               }]
             )
           when "FIELD"
-            Field.define(
+            GraphQL::Field.define(
               name: type["name"],
               type: type_resolver.call(type["type"]),
               description: type["description"],
@@ -138,7 +138,7 @@ module GraphQL
               end
             end
 
-            Argument.define(
+            GraphQL::Argument.define(
               name: type["name"],
               type: type_resolver.call(type["type"]),
               description: type["description"],

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      # Support for legacy `accepts_definitions` functions.
+      #
+      # Keep the legacy handler hooked up. Class-based types and fields
+      # will call those legacy handlers during their `.to_graphql`
+      # methods.
+      #
+      # This can help out while transitioning from one to the other.
+      # Eventually, `GraphQL::{X}Type` objects will be removed entirely,
+      # But this can help during the transition.
+      #
+      # @example Applying a function to base object class
+      #   # Here's the legacy-style config, which we're calling back to:
+      #   GraphQL::ObjectType.accepts_definition({
+      #     permission_level: ->(defn, value) { defn.metadata[:permission_level] = value }
+      #   })
+      #
+      #   class BaseObject < GraphQL::Schema::Object
+      #     # Setup a named pass-through to the legacy config functions
+      #     accepts_definition :permission_level
+      #   end
+      #
+      #   class Account < BaseObject
+      #     # This value will be passed to the legacy handler:
+      #     permission_level 1
+      #   end
+      #
+      #   # The class gets a reader method which returns the args,
+      #   # only marginally useful.
+      #   Account.permission_level # => [1]
+      #
+      #   # The legacy handler is called, as before:
+      #   Account.graphql_definition.metadata[:permission_level] # => 1
+      module AcceptsDefinition
+        def self.included(child)
+          child.extend(AcceptsDefinitionDefinitionMethods)
+          child.prepend(ToGraphQLExtension)
+          child.prepend(InitializeExtension)
+        end
+
+        def self.extended(child)
+          if defined?(child::DefinitionMethods)
+            child::DefinitionMethods.include(AcceptsDefinitionDefinitionMethods)
+            child::DefinitionMethods.prepend(ToGraphQLExtension)
+          else
+            child.extend(AcceptsDefinitionDefinitionMethods)
+            # I tried to use `super`, but super isn't quite right
+            # since the method is defined in the same class itself,
+            # not the superclass
+            child.class_eval do
+              class << self
+                prepend(ToGraphQLExtension)
+              end
+            end
+          end
+        end
+
+        module AcceptsDefinitionDefinitionMethods
+          def accepts_definition(name)
+            own_accepts_definition_methods << name
+
+            ivar_name = "@#{name}_args"
+            if self.is_a?(Class)
+              define_singleton_method(name) do |*args|
+                if args.any?
+                  instance_variable_set(ivar_name, args)
+                end
+                instance_variable_get(ivar_name) || (superclass.respond_to?(name) ? superclass.public_send(name) : nil)
+              end
+
+              define_method(name) do |*args|
+                if args.any?
+                  instance_variable_set(ivar_name, args)
+                end
+                instance_variable_get(ivar_name)
+              end
+            else
+              # Special handling for interfaces, define it here
+              # so it's appropriately passed down
+              self::DefinitionMethods.module_eval do
+                define_method(name) do |*args|
+                  if args.any?
+                    instance_variable_set(ivar_name, args)
+                  end
+                  instance_variable_get(ivar_name) || ((int = interfaces.first { |i| i.respond_to?()}) && int.public_send(name))
+                end
+              end
+            end
+          end
+
+          def accepts_definition_methods
+            inherited_methods = if self.is_a?(Class)
+              superclass.respond_to?(:accepts_definition_methods) ? superclass.accepts_definition_methods : []
+            elsif self.is_a?(Module)
+              m = []
+              ancestors.each do |a|
+                if a.respond_to?(:own_accepts_definition_methods)
+                  m.concat(a.own_accepts_definition_methods)
+                end
+              end
+              m
+            else
+              self.class.accepts_definition_methods
+            end
+
+            own_accepts_definition_methods + inherited_methods
+          end
+
+          def own_accepts_definition_methods
+            @own_accepts_definition_methods ||= []
+          end
+        end
+
+        module ToGraphQLExtension
+          def to_graphql
+            defn = super
+            accepts_definition_methods.each do |method_name|
+              value = public_send(method_name)
+              if !value.nil?
+                defn = defn.redefine { public_send(method_name, *value) }
+              end
+            end
+            defn
+          end
+        end
+
+        module InitializeExtension
+          def initialize(*args, **kwargs, &block)
+            self.class.accepts_definition_methods.each do |method_name|
+              if kwargs.key?(method_name)
+                value = kwargs.delete(method_name)
+                if !value.is_a?(Array)
+                  value = [value]
+                end
+                instance_variable_set("@#{method_name}_args", value)
+              end
+            end
+            super(*args, **kwargs, &block)
+          end
+
+          def accepts_definition_methods
+            self.class.accepts_definition_methods
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      # DSL methods shared by lots of things in the GraphQL Schema.
+      # @api private
+      # @see Classes that extend this, eg {GraphQL::Schema::Object}
+      module BaseDSLMethods
+        # 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
+        #
+        # The default name is the Ruby constant name,
+        # without any namespaces and with any `-Type` suffix removed
+        # @param new_name [String]
+        # @return [String]
+        def graphql_name(new_name = nil)
+          case
+          when new_name
+            @graphql_name = new_name
+          when overridden = overridden_graphql_name
+            overridden
+          else # Fallback to Ruby constant name
+            raise NotImplementedError, 'Anonymous class should declare an `graphql_name`' if name.nil?
+            
+            name.split("::").last.sub(/Type\Z/, "")
+          end
+        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?
+
+          fail(
+            "The new name override method is `graphql_name`, not `name`. Usage: "\
+            "graphql_name \"#{new_name}\""
+          )
+        end
+
+        # Call this method to provide a new description; OR
+        # call it without an argument to get the description
+        # @param new_description [String]
+        # @return [String]
+        def description(new_description = nil)
+          if new_description
+            @description = new_description
+          else
+            @description || find_inherited_method(:description, nil)
+          end
+        end
+
+        # @return [Boolean] If true, this object is part of the introspection system
+        def introspection(new_introspection = nil)
+          if !new_introspection.nil?
+            @introspection = new_introspection
+          else
+            @introspection || find_inherited_method(:introspection, false)
+          end
+        end
+
+        # The mutation this type was derived from, if it was derived from a mutation
+        # @return [Class]
+        def mutation(mutation_class = nil)
+          if mutation_class
+            @mutation = mutation_class
+          end
+          @mutation
+        end
+
+        # @return [GraphQL::BaseType] Convert this type to a legacy-style object.
+        def to_graphql
+          raise NotImplementedError
+        end
+
+        def overridden_graphql_name
+          @graphql_name || find_inherited_method(:overridden_graphql_name, nil)
+        end
+
+        def unwrap
+          self
+        end
+
+        private
+
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Member
+      # @api private
+      module BuildType
+        LIST_TYPE_ERROR = "Use an array of [T] or [T, null: true] for list types; other arrays are not supported"
+
+        module_function
+        # @param type_expr [String, Class, GraphQL::BaseType]
+        # @return [GraphQL::BaseType]
+        def parse_type(type_expr, null:)
+          list_type = false
+
+          return_type = case type_expr
+          when String
+            case type_expr
+            when "String"
+              GraphQL::STRING_TYPE
+            when "Int", "Integer"
+              GraphQL::INT_TYPE
+            when "Float"
+              GraphQL::FLOAT_TYPE
+            when "Boolean"
+              GraphQL::BOOLEAN_TYPE
+            when "ID"
+              GraphQL::ID_TYPE
+            when /\A\[.*\]\Z/
+              list_type = true
+              # List members are required by default
+              parse_type(type_expr[1..-2], null: false)
+            when /.*!\Z/
+              null = false
+              parse_type(type_expr[0..-2], null: true)
+            else
+              maybe_type = Object.const_get(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)
+                  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
+            type_expr
+          when Array
+            case type_expr.length
+            when 1
+              list_type = true
+              # List members are required by default
+              parse_type(type_expr.first, null: false)
+            when 2
+              inner_type, nullable_option = type_expr
+              if nullable_option.keys != [:null] || nullable_option.values != [true]
+                raise ArgumentError, LIST_TYPE_ERROR
+              end
+              list_type = true
+              parse_type(inner_type, null: true)
+            else
+              raise ArgumentError, LIST_TYPE_ERROR
+            end
+          when Module
+            # This is a way to check that it's the right kind of module:
+            if type_expr.respond_to?(:graphql_definition)
+              type_expr
+            else
+              # Eg `String` => GraphQL::STRING_TYPE
+              parse_type(type_expr.name, null: true)
+            end
+          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})"
+          end
+
+          # Apply list_type first, that way the
+          # .to_non_null_type applies to the list type, not the inner type
+          if list_type
+            return_type = return_type.to_list_type
+          end
+
+          if !null
+            return_type = return_type.to_non_null_type
+          end
+
+
+          return_type
+        end
+
+        def to_type_name(something)
+          case something
+          when GraphQL::BaseType, GraphQL::Schema::LateBoundType
+            something.unwrap.name
+          when Array
+            to_type_name(something.first)
+          when Module
+            if something.respond_to?(:graphql_name)
+              something.graphql_name
+            else
+              to_type_name(something.name)
+            end
+          when String
+            something.gsub(/\]\[\!/, "").split("::").last
+          when GraphQL::Schema::NonNull, GraphQL::Schema::List
+            to_type_name(something.unwrap)
+          else
+            raise "Unhandled to_type_name input: #{something} (#{something.class})"
+          end
+        end
+
+        def camelize(string)
+          return string unless string.include?("_")
+          camelized = string.split('_').map(&:capitalize).join
+          camelized[0] = camelized[0].downcase
+          if (match_data = string.match(/\A(_+)/))
+            camelized = "#{match_data[0]}#{camelized}"
+          end
+          camelized
+        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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      # Adds a layer of caching over user-supplied `.to_graphql` methods.
+      # Users override `.to_graphql`, but all runtime code should use `.graphql_definition`.
+      # @api private
+      # @see concrete classes that extend this, eg {Schema::Object}
+      module CachedGraphQLDefinition
+        # A cached result of {.to_graphql}.
+        # It's cached here so that user-overridden {.to_graphql} implementations
+        # are also cached
+        def graphql_definition
+          @graphql_definition ||= to_graphql
+        end
+
+        # Wipe out the cached graphql_definition so that `.to_graphql` will be called again.
+        def initialize_copy(original)
+          super
+          @graphql_definition = nil
+        end
+      end
+    end
+  end
+end