graphql 1.7.6 → 1.8.0

data/lib/graphql/schema/argument.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Argument
+      include GraphQL::Schema::Member::CachedGraphQLDefinition
+      include GraphQL::Schema::Member::AcceptsDefinition
+
+      NO_DEFAULT = :__no_default__
+
+      # @return [String] the GraphQL name for this argument, camelized unless `camelize: false` is provided
+      attr_reader :name
+
+      # @return [GraphQL::Schema::Field, Class] The field or input object this argument belongs to
+      attr_reader :owner
+
+      # @return [Symbol] A method to call to transform this value before sending it to field resolution method
+      attr_reader :prepare
+
+      # @return [Symbol] This argument's name in Ruby keyword arguments
+      attr_reader :keyword
+
+      # @param arg_name [Symbol]
+      # @param type_expr
+      # @param desc [String]
+      # @param required [Boolean] if true, this argument is non-null; if false, this argument is nullable
+      # @param description [String]
+      # @param default_value [Object]
+      # @param as [Symbol] Override the keyword name when passed to a method
+      # @param prepare [Symbol] A method to call to tranform this argument's valuebefore sending it to field resolution
+      # @param camelize [Boolean] if true, the name will be camelized when building the schema
+      def initialize(arg_name = nil, type_expr = nil, desc = nil, required:, type: nil, name: nil, description: nil, default_value: NO_DEFAULT, as: nil, camelize: true, prepare: nil, owner:, &definition_block)
+        arg_name ||= name
+        @name = camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s
+        @type_expr = type_expr || type
+        @description = desc || description
+        @null = !required
+        @default_value = default_value
+        @owner = owner
+        @as = as
+        @keyword = as || Schema::Member::BuildType.underscore(@name).to_sym
+        @prepare = prepare
+
+        if definition_block
+          instance_eval(&definition_block)
+        end
+      end
+
+      def description(text = nil)
+        if text
+          @description = text
+        else
+          @description
+        end
+      end
+
+      def to_graphql
+        argument = GraphQL::Argument.new
+        argument.name = @name
+        argument.type = -> { type }
+        argument.description = @description
+        argument.metadata[:type_class] = self
+        argument.as = @as
+        if NO_DEFAULT != @default_value
+          argument.default_value = @default_value
+        end
+        argument
+      end
+
+      def type
+        @type ||= Member::BuildType.parse_type(@type_expr, null: @null)
+      rescue StandardError => err
+        raise ArgumentError, "Couldn't build type for Argument #{@owner.name}.#{name}: #{err.class.name}: #{err.message}", err.backtrace
+      end
+
+      # Apply the {prepare} configuration to `value`, using methods from `obj`.
+      # Used by the runtime.
+      # @api private
+      def prepare_value(obj, value)
+        case @prepare
+        when nil
+          value
+        when Symbol, String
+          obj.public_send(@prepare, value)
+        when Proc
+          @prepare.call(value, obj.context)
+        else
+          raise "Invalid prepare for #{@owner.name}.name: #{@prepare.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/build_from_definition.rb

@@ -107,6 +107,8 @@ module GraphQL
             directives directives.values
           end
 
+          schema.ast_node = schema_definition if schema_definition
+
           schema
         end
 
@@ -117,18 +119,26 @@ module GraphQL
         NullScalarCoerce = ->(val, _ctx) { val }
 
         def build_enum_type(enum_type_definition, type_resolver)
-          GraphQL::EnumType.define(
+          enum = GraphQL::EnumType.define(
             name: enum_type_definition.name,
             description: enum_type_definition.description,
             values: enum_type_definition.values.map do |enum_value_definition|
-              EnumType::EnumValue.define(
+              value = EnumType::EnumValue.define(
                 name: enum_value_definition.name,
                 value: enum_value_definition.name,
                 deprecation_reason: build_deprecation_reason(enum_value_definition.directives),
                 description: enum_value_definition.description,
               )
+
+              value.ast_node = enum_value_definition
+
+              value
             end
           )
+
+          enum.ast_node = enum_type_definition
+
+          enum
         end
 
         def build_deprecation_reason(directives)
@@ -148,6 +158,8 @@ module GraphQL
             coerce: NullScalarCoerce,
           )
 
+          scalar_type.ast_node = scalar_type_definition
+
           if default_resolve.respond_to?(:coerce_input)
             scalar_type = scalar_type.redefine(
               coerce_input: ->(val, ctx) { default_resolve.coerce_input(scalar_type, val, ctx) },
@@ -159,11 +171,15 @@ module GraphQL
         end
 
         def build_union_type(union_type_definition, type_resolver)
-          GraphQL::UnionType.define(
+          union = GraphQL::UnionType.define(
             name: union_type_definition.name,
             description: union_type_definition.description,
             possible_types: union_type_definition.types.map{ |type_name| type_resolver.call(type_name) },
           )
+
+          union.ast_node = union_type_definition
+
+          union
         end
 
         def build_object_type(object_type_definition, type_resolver, default_resolve:)
@@ -175,14 +191,20 @@ module GraphQL
             fields: Hash[build_fields(object_type_definition.fields, type_resolver, default_resolve: typed_resolve_fn)],
             interfaces: object_type_definition.interfaces.map{ |interface_name| type_resolver.call(interface_name) },
           )
+          type_def.ast_node = object_type_definition
+          type_def
         end
 
         def build_input_object_type(input_object_type_definition, type_resolver)
-          GraphQL::InputObjectType.define(
+          input = GraphQL::InputObjectType.define(
             name: input_object_type_definition.name,
             description: input_object_type_definition.description,
             arguments: Hash[build_input_arguments(input_object_type_definition, type_resolver)],
           )
+
+          input.ast_node = input_object_type_definition
+
+          input
         end
 
         def build_default_value(default_value)
@@ -191,6 +213,10 @@ module GraphQL
             default_value.name
           when GraphQL::Language::Nodes::NullValue
             nil
+          when GraphQL::Language::Nodes::InputObject
+            default_value.to_h
+          when Array
+            default_value.map { |v| build_default_value(v) }
           else
             default_value
           end
@@ -204,25 +230,33 @@ module GraphQL
               kwargs[:default_value] = build_default_value(input_argument.default_value)
             end
 
+            argument = GraphQL::Argument.define(
+              name: input_argument.name,
+              type: type_resolver.call(input_argument.type),
+              description: input_argument.description,
+              **kwargs,
+            )
+
+            argument.ast_node = input_argument
+
             [
               input_argument.name,
-              GraphQL::Argument.define(
-                name: input_argument.name,
-                type: type_resolver.call(input_argument.type),
-                description: input_argument.description,
-                **kwargs,
-              )
+              argument
             ]
           end
         end
 
         def build_directive(directive_definition, type_resolver)
-          GraphQL::Directive.define(
+          directive = GraphQL::Directive.define(
             name: directive_definition.name,
             description: directive_definition.description,
             arguments: Hash[build_directive_arguments(directive_definition, type_resolver)],
             locations: directive_definition.locations.map(&:to_sym),
           )
+
+          directive.ast_node = directive_definition
+
+          directive
         end
 
         def build_directive_arguments(directive_definition, type_resolver)
@@ -233,24 +267,32 @@ module GraphQL
               kwargs[:default_value] = build_default_value(directive_argument.default_value)
             end
 
+            argument = GraphQL::Argument.define(
+              name: directive_argument.name,
+              type: type_resolver.call(directive_argument.type),
+              description: directive_argument.description,
+              **kwargs,
+            )
+
+            argument.ast_node = directive_argument
+
             [
               directive_argument.name,
-              GraphQL::Argument.define(
-                name: directive_argument.name,
-                type: type_resolver.call(directive_argument.type),
-                description: directive_argument.description,
-                **kwargs,
-              )
+              argument
             ]
           end
         end
 
         def build_interface_type(interface_type_definition, type_resolver)
-          GraphQL::InterfaceType.define(
+          interface = GraphQL::InterfaceType.define(
             name: interface_type_definition.name,
             description: interface_type_definition.description,
             fields: Hash[build_fields(interface_type_definition.fields, type_resolver, default_resolve: nil)],
           )
+
+          interface.ast_node = interface_type_definition
+
+          interface
         end
 
         def build_fields(field_definitions, type_resolver, default_resolve:)
@@ -269,6 +311,8 @@ module GraphQL
                 **kwargs,
               )
 
+              arg.ast_node = argument
+
               [argument.name, arg]
             end]
 
@@ -281,6 +325,8 @@ module GraphQL
               deprecation_reason: build_deprecation_reason(field_definition.directives),
             )
 
+            field.ast_node = field_definition
+
             type_name = resolve_type_name(field_definition.type)
             field.connection = type_name.end_with?("Connection")
             [field_definition.name, field]

data/lib/graphql/schema/enum.rb

@@ -0,0 +1,85 @@
+# 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
+      extend GraphQL::Schema::Member::AcceptsDefinition
+
+      class << self
+        extend Forwardable
+        def_delegators :graphql_definition, :coerce_isolated_input, :coerce_isolated_result
+
+        # 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]
+        # @see {Schema::EnumValue} which handles these inputs by default
+        def value(*args, **kwargs, &block)
+          kwargs[:owner] = self
+          value = enum_value_class.new(*args, **kwargs, &block)
+          own_values[value.graphql_name] = value
+          nil
+        end
+
+        # @return [Hash<String => GraphQL::Schema::Enum::Value>] Possible values of this enum, keyed by name
+        def values
+          inherited_values = superclass <= GraphQL::Schema::Enum ? superclass.values : {}
+          # Local values take precedence over inherited ones
+          inherited_values.merge(own_values)
+        end
+
+        # @return [GraphQL::EnumType]
+        def to_graphql
+          enum_type = GraphQL::EnumType.new
+          enum_type.name = graphql_name
+          enum_type.description = description
+          enum_type.introspection = introspection
+          values.each do |name, val|
+            enum_type.add_value(val.to_graphql)
+          end
+          enum_type.metadata[:type_class] = self
+          enum_type
+        end
+
+        # @return [Class] for handling `value(...)` inputs and building `GraphQL::Enum::EnumValue`s out of them
+        def enum_value_class(new_enum_value_class = nil)
+          if new_enum_value_class
+            @enum_value_class = new_enum_value_class
+          end
+          @enum_value_class || (superclass <= GraphQL::Schema::Enum ? superclass.enum_value_class : nil)
+        end
+
+        def kind
+          GraphQL::TypeKinds::ENUM
+        end
+
+        private
+
+        def own_values
+          @own_values ||= {}
+        end
+      end
+
+      enum_value_class(GraphQL::Schema::EnumValue)
+    end
+  end
+end

data/lib/graphql/schema/enum_value.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # A possible value for an {Enum}.
+    #
+    # You can extend this class to customize enum values in your schema.
+    #
+    # @example custom enum value class
+    #   # define a custom class:
+    #   class CustomEnumValue < GraphQL::Schema::EnumValue
+    #     def initialize(*args)
+    #       # arguments to `value(...)` in Enum classes are passed here
+    #       super
+    #     end
+    #
+    #     def to_graphql
+    #       enum_value = super
+    #       # customize the derived GraphQL::EnumValue here
+    #       enum_value
+    #     end
+    #   end
+    #
+    #   class BaseEnum < GraphQL::Schema::Enum
+    #     # use it for these enums:
+    #     enum_value_class CustomEnumValue
+    #   end
+    class EnumValue < GraphQL::Schema::Member
+      include GraphQL::Schema::Member::AcceptsDefinition
+
+      attr_reader :graphql_name
+
+      # @return [Class] The enum type that owns this value
+      attr_reader :owner
+
+      def initialize(graphql_name, desc = nil, owner:, description: nil, value: nil, deprecation_reason: nil, &block)
+        @graphql_name = graphql_name.to_s
+        @description = desc || description
+        @value = value || @graphql_name
+        @deprecation_reason = deprecation_reason
+        @owner = owner
+
+        if block_given?
+          instance_eval(&block)
+        end
+      end
+
+      def description(new_desc = nil)
+        if new_desc
+          @description = new_desc
+        end
+        @description
+      end
+
+      def value(new_val = nil)
+        if new_val
+          @value = new_val
+        end
+        @value
+      end
+
+      # @return [GraphQL::EnumType::EnumValue] A runtime-ready object derived from this object
+      def to_graphql
+        enum_value = GraphQL::EnumType::EnumValue.new
+        enum_value.name = @graphql_name
+        enum_value.description = @description
+        enum_value.value = @value
+        enum_value.deprecation_reason = @deprecation_reason
+        enum_value.metadata[:type_class] = self
+        enum_value
+      end
+    end
+  end
+end