graphql 1.7.14 → 1.8.0.pre1

data/lib/graphql/schema/enum.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module GraphQL
+  # Extend this class to define GraphQL enums in your schema.
+  #
+  # By default, GraphQL enum values are translated into Ruby strings.
+  # You can provide a custom value with the `value:` keyword.
+  #
+  # @example
+  #   # equivalent to
+  #   # enum PizzaTopping {
+  #   #   MUSHROOMS
+  #   #   ONIONS
+  #   #   PEPPERS
+  #   # }
+  #   class PizzaTopping < GraphQL::Enum
+  #     value :MUSHROOMS
+  #     value :ONIONS
+  #     value :PEPPERS
+  #   end
+  class Schema
+    class Enum < GraphQL::Schema::Member
+      # @api private
+      Value = Struct.new(:name, :description, :value, :deprecation_reason)
+
+      class << self
+        # Define a value for this enum
+        # @param graphql_name [String, Symbol] the GraphQL value for this, usually `SCREAMING_CASE`
+        # @param description [String], the GraphQL description for this value, present in documentation
+        # @param value [Object], the translated Ruby value for this object (defaults to `graphql_name`)
+        # @param deprecation_reason [String] if this object is deprecated, include a message here
+        # @return [void]
+        def value(graphql_name, description = nil, value: nil, deprecation_reason: nil)
+          graphql_name = graphql_name.to_s
+          value ||= graphql_name
+          own_values << Value.new(graphql_name, description, value, deprecation_reason)
+          nil
+        end
+
+        # @return [Array<GraphQL::Schema::Enum::Value>]
+        def values
+          all_values = own_values
+          inherited_values = superclass <= GraphQL::Schema::Enum ? superclass.values : []
+          inherited_values.each do |inherited_v|
+            if all_values.none? { |v| v.name == inherited_v.name }
+              all_values << inherited_v
+            end
+          end
+          all_values
+        end
+
+        # @return [GraphQL::EnumType]
+        def to_graphql
+          enum_type = GraphQL::EnumType.new
+          enum_type.name = graphql_name
+          enum_type.description = description
+          values.each do |val|
+            enum_value = GraphQL::EnumType::EnumValue.new
+            enum_value.name = val.name
+            enum_value.description = val.description
+            enum_value.value = val.value
+            enum_value.deprecation_reason = val.deprecation_reason
+            enum_type.add_value(enum_value)
+          end
+          enum_type
+        end
+
+        private
+
+        def own_values
+          @own_values ||= []
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/field.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+# test_via: ../object.rb
+require "graphql/schema/field/dynamic_resolve"
+require "graphql/schema/field/unwrapped_resolve"
+module GraphQL
+  class Schema
+    class Field
+      include GraphQL::Schema::Member::CachedGraphQLDefinition
+
+      # @return [String]
+      attr_reader :name
+
+      # @return [String]
+      attr_reader :description
+
+      def initialize(name, return_type_expr = nil, desc = nil, null: nil, field: nil, function: nil, deprecation_reason: nil, method: nil, connection: nil, max_page_size: nil, resolve: nil, &args_block)
+        if !(field || function)
+          if return_type_expr.nil?
+            raise ArgumentError "missing possitional argument `type`"
+          end
+          if null.nil?
+            raise ArgumentError, "missing keyword argument null:"
+          end
+        end
+        @name = name.to_s
+        @description = desc
+        @field = field
+        @function = function
+        @resolve = resolve
+        @deprecation_reason = deprecation_reason
+        @method = method
+        @return_type_expr = return_type_expr
+        @return_type_null = null
+        @args_block = args_block
+        @connection = connection
+        @max_page_size = max_page_size
+      end
+
+      # @return [GraphQL::Field]
+      def to_graphql
+        method_name = @method || Member::BuildType.underscore(@name)
+
+        field_defn = if @field
+          @field.dup
+        elsif @function
+          GraphQL::Function.build_field(@function)
+        else
+          GraphQL::Field.new
+        end
+        field_defn.name = @name
+
+        if @return_type_expr
+          return_type_name = Member::BuildType.to_type_name(@return_type_expr)
+          connection = @connection.nil? ? return_type_name.end_with?("Connection") : @connection
+          field_defn.type = -> {
+            Member::BuildType.parse_type(@return_type_expr, null: @return_type_null)
+          }
+        elsif @connection.nil? && (@field || @function)
+          return_type_name = Member::BuildType.to_type_name(field_defn.type)
+          connection = return_type_name.end_with?("Connection")
+        else
+          connection = @connection
+        end
+
+        if @description
+          field_defn.description = @description
+        end
+
+        if @deprecation_reason
+          field_defn.deprecation_reason = @deprecation_reason
+        end
+
+        field_defn.resolve = if @resolve || @function || @field
+          prev_resolve = @resolve || field_defn.resolve_proc
+          UnwrappedResolve.new(inner_resolve: prev_resolve)
+        else
+          DynamicResolve.new(method_name: method_name, connection: connection)
+        end
+
+        field_defn.connection = connection
+        field_defn.connection_max_page_size = @max_page_size
+
+        field_proxy = FieldProxy.new(field_defn, argument_class: self.class.argument_class)
+        # apply this first, so it can be overriden below
+        if connection
+          field_proxy.argument :after, "String", "Returns the elements in the list that come after the specified global ID.", required: false
+          field_proxy.argument :before, "String", "Returns the elements in the list that come before the specified global ID.", required: false
+          field_proxy.argument :first, "Int", "Returns the first _n_ elements from the list.", required: false
+          field_proxy.argument :last, "Int", "Returns the last _n_ elements from the list.", required: false
+        end
+
+        if @args_block
+          field_proxy.instance_eval(&@args_block)
+        end
+
+        field_defn
+      end
+
+      class << self
+        def argument_class(new_arg_class = nil)
+          if new_arg_class
+            @argument_class = new_arg_class
+          else
+            @argument_class || GraphQL::Schema::Argument
+          end
+        end
+      end
+
+
+      # This object exists only to be `instance_eval`'d
+      # when the `field(...)` method is called with a block.
+      # This object receives that block.
+      class FieldProxy
+        def initialize(field, argument_class:)
+          @field = field
+          @argument_class = argument_class
+        end
+
+        # This is the `argument(...)` DSL for class-based field definitons
+        def argument(*args)
+          arg = @argument_class.new(*args)
+          @field.arguments[arg.name] = arg.graphql_definition
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/field/dynamic_resolve.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Field
+      class DynamicResolve
+        def initialize(method_name:, connection:)
+          @method_name = method_name
+          @connection = connection
+        end
+
+        def call(obj, args, ctx)
+          if obj.respond_to?(@method_name)
+            public_send_field(obj, @method_name, args)
+          elsif obj.object.respond_to?(@method_name)
+            public_send_field(obj.object, @method_name, args)
+          elsif obj.is_a?(Hash)
+            obj[@method_name]
+          else
+            raise <<-ERR
+Failed to implement #{ctx.irep_node.owner_type.name}.#{ctx.field.name}, tried:
+
+- `#{obj.class}##{@method_name}`, which did not exist
+- `#{obj.object.class}##{@method_name}`, which did not exist
+- Looking up hash key `#{@method_name.inspect}` on `#{obj}`, but it wasn't a Hash
+
+To implement this field, define one of the methods above (and check for typos)
+ERR
+          end
+        end
+
+        private
+
+        def public_send_field(obj, method_name, graphql_args)
+          if graphql_args.any?
+            # Splat the GraphQL::Arguments to Ruby keyword arguments
+            ruby_kwargs = {}
+
+            graphql_args.keys.each do |key|
+              ruby_kwargs[Schema::Member::BuildType.underscore(key).to_sym] = graphql_args[key]
+            end
+
+            if @connection
+              # Remove pagination args before passing it to a user method
+              ruby_kwargs.delete(:first)
+              ruby_kwargs.delete(:last)
+              ruby_kwargs.delete(:before)
+              ruby_kwargs.delete(:after)
+            end
+
+            if ruby_kwargs.any?
+              obj.public_send(method_name, ruby_kwargs)
+            else
+              obj.public_send(method_name)
+            end
+          else
+            obj.public_send(method_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/field/unwrapped_resolve.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Field
+      # This object is backed by an `Object`, but the resolve isn't expecting
+      # that wrapper, so unwrap it before calling the inner resolver
+      class UnwrappedResolve
+        def initialize(inner_resolve:)
+          @inner_resolve = inner_resolve
+        end
+
+        def call(obj, args, ctx)
+          # Might be nil, still want to call the func in that case
+          inner_obj = obj && obj.object
+          @inner_resolve.call(inner_obj, args, ctx)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/input_object.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class InputObject < GraphQL::Schema::Member
+      extend GraphQL::Delegate
+
+      def initialize(values, context:)
+        @arguments = self.class.arguments_class.new(values, context: context)
+        @context = context
+      end
+
+      # A lot of methods work just like GraphQL::Arguments
+      def_delegators :@arguments, :[], :key?, :to_h
+      def_delegators :to_h, :keys, :values, :each, :any?
+
+      class << self
+        # @return [Class<GraphQL::Arguments>]
+        attr_accessor :arguments_class
+
+        def argument(*args)
+          argument = GraphQL::Schema::Argument.new(*args)
+          own_arguments << argument
+          arg_name = argument.name
+          # Add a method access
+          define_method(Member::BuildType.underscore(arg_name)) do
+            @arguments.public_send(arg_name)
+          end
+        end
+
+        def arguments
+          all_arguments = own_arguments
+          inherited_arguments = (superclass <= GraphQL::Schema::InputObject ? superclass.arguments : [])
+          inherited_arguments.each do |inherited_a|
+            if all_arguments.none? { |a| a.name == inherited_a.name }
+              all_arguments << inherited_a
+            end
+          end
+          all_arguments
+        end
+
+        def own_arguments
+          @own_arguments ||= []
+        end
+
+        def to_graphql
+          type_defn = GraphQL::InputObjectType.new
+          type_defn.name = graphql_name
+          type_defn.description = description
+          arguments.each do |arg|
+            type_defn.arguments[arg.name] = arg.graphql_definition
+          end
+          # Make a reference to a classic-style Arguments class
+          self.arguments_class = GraphQL::Query::Arguments.construct_arguments_class(type_defn)
+          # But use this InputObject class at runtime
+          type_defn.arguments_class = self
+          type_defn
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/interface.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Interface < GraphQL::Schema::Member
+      extend GraphQL::Schema::Member::HasFields
+      field_class GraphQL::Schema::Field
+
+      class << self
+
+        # When this interface is added to a `GraphQL::Schema::Object`,
+        # it calls this method. We add methods to the object by convention,
+        # a nested module named `Implementation`
+        def apply_implemented(object_class)
+          if defined?(self::Implementation)
+            object_class.include(self::Implementation)
+          end
+        end
+
+        def to_graphql
+          type_defn = GraphQL::InterfaceType.new
+          type_defn.name = graphql_name
+          type_defn.description = description
+          fields.each do |field_inst|
+            field_defn = field_inst.graphql_definition
+            type_defn.fields[field_defn.name] = field_defn
+          end
+          type_defn
+        end
+      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.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+module GraphQL
+  # The base class for things that make up the schema,
+  # eg objects, enums, scalars.
+  #
+  # @api private
+  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`.
+      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
+      end
+
+      # These constants are interpreted as GraphQL types
+      #
+      # @example
+      #   field :isDraft, Boolean, null: false
+      #   field :id, ID, null: false
+      module GraphQLTypeNames
+        Boolean = "Boolean"
+        ID = "ID"
+      end
+
+      include GraphQLTypeNames
+      class << self
+        include CachedGraphQLDefinition
+
+        # Delegate to the derived type definition if possible.
+        # This is tricky because missing methods cause the definition to be built & cached.
+        def method_missing(method_name, *args, &block)
+          if graphql_definition.respond_to?(method_name)
+            graphql_definition.public_send(method_name, *args, &block)
+          else
+            super
+          end
+        end
+
+        # Check if the derived type definition responds to the method
+        # @return [Boolean]
+        def respond_to_missing?(method_name, incl_private = false)
+          graphql_definition.respond_to?(method_name, incl_private) || super
+        end
+
+        # 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)
+          if new_name
+            @graphql_name = new_name
+          else
+            @graphql_name || self.name.split("::").last.sub(/Type\Z/, "")
+          end
+        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 || (superclass <= GraphQL::Schema::Member ? superclass.description : nil)
+          end
+        end
+
+        def to_graphql
+          raise NotImplementedError
+        end
+
+        def to_list_type
+          ListTypeProxy.new(self)
+        end
+
+        def to_non_null_type
+          NonNullTypeProxy.new(self)
+        end
+      end
+    end
+  end
+end
+
+require 'graphql/schema/member/list_type_proxy'
+require 'graphql/schema/member/non_null_type_proxy'
+require 'graphql/schema/member/has_fields'
+require 'graphql/schema/member/instrumentation'
+require 'graphql/schema/member/build_type'