graphql 1.7.6 → 1.8.0

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      # These constants are interpreted as GraphQL types when defining fields or arguments
+      #
+      # @example
+      #   field :is_draft, Boolean, null: false
+      #   field :id, ID, null: false
+      #   field :score, Int, null: false
+      #
+      # @api private
+      module GraphQLTypeNames
+        Boolean = "Boolean"
+        ID = "ID"
+        Int = "Int"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Member
+      module HasArguments
+        def self.included(cls)
+          cls.extend(ArgumentClassAccessor)
+        end
+
+        def self.extended(cls)
+          cls.extend(ArgumentClassAccessor)
+        end
+
+        # @see {GraphQL::Schema::Argument#initialize} for parameters
+        # @return [GraphQL::Schema::Argument] An instance of {arguments_class}, created from `*args`
+        def argument(*args, **kwargs, &block)
+          kwargs[:owner] = self
+          arg_defn = self.argument_class.new(*args, **kwargs, &block)
+          own_arguments[arg_defn.name] = arg_defn
+        end
+
+        # @return [Hash<String => GraphQL::Schema::Argument] Arguments defined on this thing, keyed by name. Includes inherited definitions
+        def arguments
+          inherited_arguments = ((self.is_a?(Class) && superclass.respond_to?(:arguments)) ? superclass.arguments : {})
+          # Local definitions override inherited ones
+          inherited_arguments.merge(own_arguments)
+        end
+
+        # @param new_arg_class [Class] A class to use for building argument definitions
+        def argument_class(new_arg_class = nil)
+          self.class.argument_class(new_arg_class)
+        end
+
+        module ArgumentClassAccessor
+          def argument_class(new_arg_class = nil)
+            if new_arg_class
+              @argument_class = new_arg_class
+            else
+              @argument_class || (superclass.respond_to?(:argument_class) ? superclass.argument_class : GraphQL::Schema::Argument)
+            end
+          end
+        end
+
+        def own_arguments
+          @own_arguments ||= {}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Member
+      # Shared code for Object and Interface
+      module HasFields
+        class << self
+          # When this module is added to a class,
+          # add a place for that class's default behaviors
+          def self.extended(child_class)
+            add_default_resolve_module(child_class)
+            super
+          end
+
+          # Create a module which will have instance methods for implementing fields.
+          # These will be `super` methods for fields in interfaces, objects and mutations.
+          # Use an instance variable on the class instead of a constant
+          # so that module namespaces won't be an issue. (If we used constants,
+          # `child_class::DefaultResolve` might find a constant from an included module.)
+          def add_default_resolve_module(child_class)
+            if child_class.instance_variable_get(:@_default_resolve)
+              # This can happen when an object implements an interface,
+              # since that interface has the `included` hook above.
+              return
+            end
+
+            default_resolve_module = Module.new
+            child_class.instance_variable_set(:@_default_resolve, default_resolve_module)
+            child_class.include(default_resolve_module)
+          end
+        end
+
+        # When this is included into interfaces,
+        # add a place for default field behaviors
+        def included(child_class)
+          HasFields.add_default_resolve_module(child_class)
+          # Also, prepare a place for default field implementations
+          super
+        end
+
+        # When a subclass of objects are created,
+        # add a place for that subclass's default field behaviors
+        def inherited(child_class)
+          HasFields.add_default_resolve_module(child_class)
+          super
+        end
+
+        # Add a field to this object or interface with the given definition
+        # @see {GraphQL::Schema::Field#initialize} for method signature
+        # @return [void]
+        def field(*args, **kwargs, &block)
+          field_defn = field_class.from_options(*args, owner: self, **kwargs, &block)
+          add_field(field_defn)
+          nil
+        end
+
+        # @return [Hash<String => GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields
+        def fields
+          # Local overrides take precedence over inherited fields
+          all_fields = {}
+          ancestors.reverse_each do |ancestor|
+            if ancestor.respond_to?(:own_fields)
+              all_fields.merge!(ancestor.own_fields)
+            end
+          end
+          all_fields
+        end
+
+        # Register this field with the class, overriding a previous one if needed.
+        # Also, add a parent method for resolving this field.
+        # @param field_defn [GraphQL::Schema::Field]
+        # @return [void]
+        def add_field(field_defn)
+          own_fields[field_defn.name] = field_defn
+          if !method_defined?(field_defn.method_sym)
+            # Only add the super method if there isn't one already.
+            add_super_method(field_defn.name.inspect, field_defn.method_sym)
+          end
+          nil
+        end
+
+        # @return [Class] The class to initialize when adding fields to this kind of schema member
+        def field_class(new_field_class = nil)
+          if new_field_class
+            @field_class = new_field_class
+          elsif @field_class
+            @field_class
+          elsif self.is_a?(Class)
+            superclass.respond_to?(:field_class) ? superclass.field_class : GraphQL::Schema::Field
+          else
+            ancestor = ancestors[1..-1].find { |a| a.respond_to?(:field_class) && a.field_class }
+            ancestor ? ancestor.field_class : GraphQL::Schema::Field
+          end
+        end
+
+        def global_id_field(field_name)
+          field field_name, "ID", null: false, resolve: GraphQL::Relay::GlobalIdResolve.new(type: self)
+        end
+
+        # @return [Array<GraphQL::Schema::Field>] Fields defined on this class _specifically_, not parent classes
+        def own_fields
+          @own_fields ||= {}
+        end
+
+        private
+        # Find the magic module for holding super methods,
+        # and add a field named `method_name` for implementing the field
+        # called `field_name`.
+        # It will be the `super` method if the method is overwritten in the class definition.
+        def add_super_method(field_key, method_name)
+          default_resolve_module = @_default_resolve
+          if default_resolve_module.nil?
+            # This should have been set up in one of the inherited or included hooks above,
+            # if it wasn't, it's because those hooks weren't called because `super` wasn't present.
+            raise <<-ERR
+Uh oh! #{self} doesn't have a default resolve module. This probably means that an `inherited` hook didn't call super.
+Check `inherited` on #{self}'s superclasses.
+ERR
+          end
+          default_resolve_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method_name}(**args)
+              field_inst = self.class.fields[#{field_key}] || raise(%|Failed to find field #{field_key} for \#{self.class} among \#{self.class.fields.keys}|)
+              field_inst.resolve_field_method(self, args, context)
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+# test_via: ../object.rb
+
+module GraphQL
+  class Schema
+    class Member
+      module Instrumentation
+        module_function
+        def instrument(type, field)
+          return_type = field.type.unwrap
+          if (return_type.is_a?(GraphQL::ObjectType) && return_type.metadata[:type_class]) ||
+              return_type.is_a?(GraphQL::InterfaceType) ||
+              (return_type.is_a?(GraphQL::UnionType) && return_type.possible_types.any? { |t| t.metadata[:type_class] })
+            field = apply_proxy(field)
+          end
+
+          field
+        end
+
+        def before_query(query)
+          # Get the root type for this query
+          root_node = query.irep_selection
+          if root_node.nil?
+            # It's an invalid query, nothing to do here
+          else
+            root_type = query.irep_selection.return_type
+            # If it has a wrapper, apply it
+            wrapper_class = root_type.metadata[:type_class]
+            if wrapper_class
+              new_root_value = wrapper_class.new(query.root_value, query.context)
+              query.root_value = new_root_value
+            end
+          end
+        end
+
+        def after_query(_query)
+        end
+
+        private
+
+        module_function
+
+        def apply_proxy(field)
+          resolve_proc = field.resolve_proc
+          lazy_resolve_proc = field.lazy_resolve_proc
+          inner_return_type = field.type.unwrap
+          depth = list_depth(field.type)
+
+          field.redefine(
+            resolve: ProxiedResolve.new(inner_resolve: resolve_proc, list_depth: depth, inner_return_type: inner_return_type),
+            lazy_resolve: ProxiedResolve.new(inner_resolve: lazy_resolve_proc, list_depth: depth, inner_return_type: inner_return_type),
+          )
+        end
+
+        def list_depth(type, starting_at = 0)
+          case type
+          when GraphQL::ListType
+            list_depth(type.of_type, starting_at + 1)
+          when GraphQL::NonNullType
+            list_depth(type.of_type, starting_at)
+          else
+            starting_at
+          end
+        end
+
+        class ProxiedResolve
+          def initialize(inner_resolve:, list_depth:, inner_return_type:)
+            @inner_resolve = inner_resolve
+            @inner_return_type = inner_return_type
+            @list_depth = list_depth
+          end
+
+          def call(obj, args, ctx)
+            result = @inner_resolve.call(obj, args, ctx)
+            if ctx.schema.lazy?(result)
+              # Wrap it later
+              result
+            elsif ctx.skip == result
+              result
+            else
+              proxy_to_depth(result, @list_depth, @inner_return_type, ctx)
+            end
+          end
+
+          private
+
+          def proxy_to_depth(obj, depth, type, ctx)
+            if obj.nil?
+              obj
+            elsif depth > 0
+              obj.map { |inner_obj| proxy_to_depth(inner_obj, depth - 1, type, ctx) }
+            else
+              concrete_type = case type
+              when GraphQL::UnionType, GraphQL::InterfaceType
+                ctx.query.resolve_type(type, obj)
+              when GraphQL::ObjectType
+                type
+              else
+                raise "unexpected proxying type #{type} for #{obj} at #{ctx.owner_type}.#{ctx.field.name}"
+              end
+
+              if concrete_type && (object_class = concrete_type.metadata[:type_class])
+                # use the query-level context here, since it won't be field-specific anyways
+                query_ctx = ctx.query.context
+                object_class.new(obj, query_ctx)
+              else
+                obj
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Member
+      module TypeSystemHelpers
+        # @return [Schema::NonNull] Make a non-null-type representation of this type
+        def to_non_null_type
+          GraphQL::Schema::NonNull.new(self)
+        end
+
+        # @return [Schema::List] Make a list-type representation of this type
+        def to_list_type
+          GraphQL::Schema::List.new(self)
+        end
+
+        # @return [Boolean] true if this is a non-nullable type. A nullable list of non-nullables is considered nullable.
+        def non_null?
+          false
+        end
+
+        # @return [Boolean] true if this is a list type. A non-nullable list is considered a list.
+        def list?
+          false
+        end
+
+        # @return [GraphQL::TypeKinds::TypeKind]
+        def kind
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/member.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require 'graphql/schema/member/accepts_definition'
+require 'graphql/schema/member/base_dsl_methods'
+require 'graphql/schema/member/cached_graphql_definition'
+require 'graphql/schema/member/graphql_type_names'
+require 'graphql/schema/member/type_system_helpers'
+require "graphql/relay/type_extensions"
+
+module GraphQL
+  # The base class for things that make up the schema,
+  # eg objects, enums, scalars.
+  #
+  # @api private
+  class Schema
+    class Member
+      include GraphQLTypeNames
+      extend CachedGraphQLDefinition
+      extend GraphQL::Relay::TypeExtensions
+      extend BaseDSLMethods
+      extend TypeSystemHelpers
+    end
+  end
+end
+
+require 'graphql/schema/member/has_arguments'
+require 'graphql/schema/member/has_fields'
+require 'graphql/schema/member/instrumentation'
+require 'graphql/schema/member/build_type'

data/lib/graphql/schema/middleware_chain.rb

@@ -5,7 +5,7 @@ module GraphQL
     #
     # Steps should call `next_step.call` to continue the chain, or _not_ call it to stop the chain.
     class MiddlewareChain
-      extend GraphQL::Delegate
+      extend Forwardable
 
       # @return [Array<#call(*args)>] Steps in this chain, will be called with arguments and `next_middleware`
       attr_reader :steps, :final_step
@@ -38,6 +38,10 @@ module GraphQL
         invoke_core(0, arguments)
       end
 
+      def concat(callables)
+        callables.each { |c| add_middleware(c) }
+      end
+
       private
 
       def invoke_core(index, arguments)

data/lib/graphql/schema/mutation.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # This base class accepts configuration for a mutation root field,
+    # then it can be hooked up to your mutation root object type.
+    #
+    # If you want to customize how this class generates types, in your base class,
+    # override the various `generate_*` methods.
+    #
+    # @see {GraphQL::Schema::RelayClassicMutation} for an extension of this class with some conventions built-in.
+    #
+    # @example Creating a comment
+    #  # Define the mutation:
+    #  class Mutations::CreateComment < GraphQL::Schema::Mutation
+    #    argument :body, String, required: true
+    #    argument :post_id, ID, required: true
+    #
+    #    field :comment, Types::Comment, null: true
+    #    field :error_messages, [String], null: false
+    #
+    #    def resolve(body:, post_id:)
+    #      post = Post.find(post_id)
+    #      comment = post.comments.build(body: body, author: context[:current_user])
+    #      if comment.save
+    #        # Successful creation, return the created object with no errors
+    #        {
+    #          comment: comment,
+    #          errors: [],
+    #        }
+    #      else
+    #        # Failed save, return the errors to the client
+    #        {
+    #          comment: nil,
+    #          errors: comment.errors.full_messages
+    #        }
+    #      end
+    #    end
+    #  end
+    #
+    #  # Hook it up to your mutation:
+    #  class Types::Mutation < GraphQL::Schema::Object
+    #    field :create_comment, mutation: Mutations::CreateComment
+    #  end
+    #
+    #  # Call it from GraphQL:
+    #  result = MySchema.execute <<-GRAPHQL
+    #  mutation {
+    #    createComment(postId: "1", body: "Nice Post!") {
+    #      errors
+    #      comment {
+    #        body
+    #        author {
+    #          login
+    #        }
+    #      }
+    #    }
+    #  }
+    #  GRAPHQL
+    #
+    class Mutation < GraphQL::Schema::Resolver
+      extend GraphQL::Schema::Member::HasFields
+
+      class << self
+        # Override this method to handle legacy-style usages of `MyMutation.field`
+        def field(*args, &block)
+          if args.none?
+            raise ArgumentError, "#{name}.field is used for adding fields to this mutation. Use `mutation: #{name}` to attach this mutation instead."
+          else
+            super
+          end
+        end
+
+        # Call this method to get the derived return type of the mutation,
+        # or use it as a configuration method to assign a return type
+        # instead of generating one.
+        # @param new_payload_type [Class, nil] If a type definition class is provided, it will be used as the return type of the mutation field
+        # @return [Class] The object type which this mutation returns.
+        def payload_type(new_payload_type = nil)
+          if new_payload_type
+            @payload_type = new_payload_type
+          end
+          @payload_type ||= generate_payload_type
+        end
+
+        alias :type :payload_type
+        alias :type_expr :payload_type
+
+        # An object class to use for deriving payload types
+        # @param new_class [Class, nil] Defaults to {GraphQL::Schema::Object}
+        # @return [Class]
+        def object_class(new_class = nil)
+          if new_class
+            @object_class = new_class
+          end
+          @object_class || (superclass.respond_to?(:object_class) ? superclass.object_class : GraphQL::Schema::Object)
+        end
+
+        def field_class(new_class = nil)
+          if new_class
+            @field_class = new_class
+          else
+            @field_class || find_inherited_method(:field_class, GraphQL::Schema::Field)
+          end
+        end
+
+        # An object class to use for deriving return types
+        # @param new_class [Class, nil] Defaults to {GraphQL::Schema::Object}
+        # @return [Class]
+        def object_class(new_class = nil)
+          if new_class
+            @object_class = new_class
+          end
+          @object_class || (superclass.respond_to?(:object_class) ? superclass.object_class : GraphQL::Schema::Object)
+        end
+
+        private
+
+        # Build a subclass of {.object_class} based on `self`.
+        # This value will be cached as `{.payload_type}`.
+        # Override this hook to customize return type generation.
+        def generate_payload_type
+          mutation_name = graphql_name
+          mutation_fields = fields
+          mutation_class = self
+          Class.new(object_class) do
+            graphql_name("#{mutation_name}Payload")
+            description("Autogenerated return type of #{mutation_name}")
+            mutation(mutation_class)
+            mutation_fields.each do |name, f|
+              field(name, field: f)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/non_null.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # Wraps a {Schema::Member} when it is required.
+    # @see {Schema::Member::TypeSystemHelpers#to_non_null_type}
+    class NonNull
+      include GraphQL::Schema::Member::CachedGraphQLDefinition
+      include GraphQL::Schema::Member::TypeSystemHelpers
+      attr_reader :of_type
+      def initialize(of_type)
+        @of_type = of_type
+      end
+
+      def to_graphql
+        @of_type.graphql_definition.to_non_null_type
+      end
+
+      # @return [true]
+      def non_null?
+        true
+      end
+
+      # @return [Boolean] True if this type wraps a list type
+      def list?
+        @of_type.list?
+      end
+
+      def kind
+        GraphQL::TypeKinds::NON_NULL
+      end
+
+      def unwrap
+        @of_type.unwrap
+      end
+    end
+  end
+end

data/lib/graphql/schema/object.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Object < GraphQL::Schema::Member
+      extend GraphQL::Schema::Member::AcceptsDefinition
+      extend GraphQL::Schema::Member::HasFields
+
+      # @return [Object] the application object this type is wrapping
+      attr_reader :object
+
+      # @return [GraphQL::Query::Context] the context instance for this query
+      attr_reader :context
+
+      def initialize(object, context)
+        @object = object
+        @context = context
+      end
+
+      class << self
+        def implements(*new_interfaces)
+          new_interfaces.each do |int|
+            if int.is_a?(Module)
+              # Include the methods here,
+              # `.fields` will use the inheritance chain
+              # to find inherited fields
+              include(int)
+            end
+          end
+          own_interfaces.concat(new_interfaces)
+        end
+
+        def interfaces
+          own_interfaces + (superclass <= GraphQL::Schema::Object ? superclass.interfaces : [])
+        end
+
+        def own_interfaces
+          @own_interfaces ||= []
+        end
+
+        # Include legacy-style interfaces, too
+        def fields
+          all_fields = super
+          interfaces.each do |int|
+            if int.is_a?(GraphQL::InterfaceType)
+              int_f = {}
+              int.fields.each do |name, legacy_field|
+                int_f[name] = field_class.from_options(name, field: legacy_field)
+              end
+              all_fields = int_f.merge(all_fields)
+            end
+          end
+          all_fields
+        end
+
+        # @return [GraphQL::ObjectType]
+        def to_graphql
+          obj_type = GraphQL::ObjectType.new
+          obj_type.name = graphql_name
+          obj_type.description = description
+          obj_type.interfaces = interfaces
+          obj_type.introspection = introspection
+          obj_type.mutation = mutation
+
+          fields.each do |field_name, field_inst|
+            field_defn = field_inst.to_graphql
+            obj_type.fields[field_defn.name] = field_defn
+          end
+
+          obj_type.metadata[:type_class] = self
+
+          obj_type
+        end
+
+        def kind
+          GraphQL::TypeKinds::OBJECT
+        end
+      end
+    end
+  end
+end