graphql 0.16.0 → 2.0.15

data/lib/graphql/schema/field_extension.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    # Extend this class to make field-level customizations to resolve behavior.
+    #
+    # When a extension is added to a field with `extension(MyExtension)`, a `MyExtension` instance
+    # is created, and its hooks are applied whenever that field is called.
+    #
+    # The instance is frozen so that instance variables aren't modified during query execution,
+    # which could cause all kinds of issues due to race conditions.
+    class FieldExtension
+      # @return [GraphQL::Schema::Field]
+      attr_reader :field
+
+      # @return [Object]
+      attr_reader :options
+
+      # @return [Array<Symbol>, nil] `default_argument`s added, if any were added (otherwise, `nil`)
+      attr_reader :added_default_arguments
+
+      # Called when the extension is mounted with `extension(name, options)`.
+      # The instance will be frozen to avoid improper use of state during execution.
+      # @param field [GraphQL::Schema::Field] The field where this extension was mounted
+      # @param options [Object] The second argument to `extension`, or `{}` if nothing was passed.
+      def initialize(field:, options:)
+        @field = field
+        @options = options || {}
+        @added_default_arguments = nil
+        apply
+      end
+
+      class << self
+        # @return [Array(Array, Hash), nil] A list of default argument configs, or `nil` if there aren't any
+        def default_argument_configurations
+          args = superclass.respond_to?(:default_argument_configurations) ? superclass.default_argument_configurations : nil
+          if @own_default_argument_configurations
+            if args
+              args.concat(@own_default_argument_configurations)
+            else
+              args = @own_default_argument_configurations.dup
+            end
+          end
+          args
+        end
+
+        # @see Argument#initialize
+        # @see HasArguments#argument
+        def default_argument(*argument_args, **argument_kwargs)
+          configs = @own_default_argument_configurations ||= []
+          configs << [argument_args, argument_kwargs]
+        end
+
+        # If configured, these `extras` will be added to the field if they aren't already present,
+        # but removed by from `arguments` before the field's `resolve` is called.
+        # (The extras _will_ be present for other extensions, though.)
+        #
+        # @param new_extras [Array<Symbol>] If provided, assign extras used by this extension
+        # @return [Array<Symbol>] any extras assigned to this extension
+        def extras(new_extras = nil)
+          if new_extras
+            @own_extras = new_extras
+          end
+
+          inherited_extras = self.superclass.respond_to?(:extras) ? superclass.extras : nil
+          if @own_extras
+            if inherited_extras
+              inherited_extras + @own_extras
+            else
+              @own_extras
+            end
+          elsif inherited_extras
+            inherited_extras
+          else
+            NO_EXTRAS
+          end
+        end
+      end
+
+      NO_EXTRAS = [].freeze
+      private_constant :NO_EXTRAS
+
+      # Called when this extension is attached to a field.
+      # The field definition may be extended during this method.
+      # @return [void]
+      def apply
+      end
+
+      # Called after the field's definition block has been executed.
+      # (Any arguments from the block are present on `field`)
+      # @return [void]
+      def after_define
+      end
+
+      # @api private
+      def after_define_apply
+        after_define
+        if (configs = self.class.default_argument_configurations)
+          existing_keywords = field.all_argument_definitions.map(&:keyword)
+          existing_keywords.uniq!
+          @added_default_arguments = []
+          configs.each do |config|
+            argument_args, argument_kwargs = config
+            arg_name = argument_args[0]
+            if !existing_keywords.include?(arg_name)
+              @added_default_arguments << arg_name
+              field.argument(*argument_args, **argument_kwargs)
+            end
+          end
+        end
+        if (extras = self.class.extras).any?
+          @added_extras = extras - field.extras
+          field.extras(@added_extras)
+        else
+          @added_extras = nil
+        end
+        freeze
+      end
+
+      # @api private
+      attr_reader :added_extras
+
+      # Called before resolving {#field}. It should either:
+      #
+      # - `yield` values to continue execution; OR
+      # - return something else to shortcut field execution.
+      #
+      # Whatever this method returns will be used for execution.
+      #
+      # @param object [Object] The object the field is being resolved on
+      # @param arguments [Hash] Ruby keyword arguments for resolving this field
+      # @param context [Query::Context] the context for this query
+      # @yieldparam object [Object] The object to continue resolving the field on
+      # @yieldparam arguments [Hash] The keyword arguments to continue resolving with
+      # @yieldparam memo [Object] Any extension-specific value which will be passed to {#after_resolve} later
+      # @return [Object] The return value for this field.
+      def resolve(object:, arguments:, context:)
+        yield(object, arguments, nil)
+      end
+
+      # Called after {#field} was resolved, and after any lazy values (like `Promise`s) were synced,
+      # but before the value was added to the GraphQL response.
+      #
+      # Whatever this hook returns will be used as the return value.
+      #
+      # @param object [Object] The object the field is being resolved on
+      # @param arguments [Hash] Ruby keyword arguments for resolving this field
+      # @param context [Query::Context] the context for this query
+      # @param value [Object] Whatever the field previously returned
+      # @param memo [Object] The third value yielded by {#resolve}, or `nil` if there wasn't one
+      # @return [Object] The return value for this field.
+      def after_resolve(object:, arguments:, context:, value:, memo:)
+        value
+      end
+    end
+  end
+end

data/lib/graphql/schema/find_inherited_value.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    module FindInheritedValue
+      module EmptyObjects
+        EMPTY_HASH = {}.freeze
+        EMPTY_ARRAY = [].freeze
+      end
+
+      def self.extended(child_cls)
+        child_cls.singleton_class.include(EmptyObjects)
+      end
+
+      def self.included(child_cls)
+        child_cls.include(EmptyObjects)
+      end
+
+      private
+
+      def find_inherited_value(method_name, default_value = nil)
+        if self.is_a?(Class)
+          superclass.respond_to?(method_name, true) ? superclass.send(method_name) : default_value
+        else
+          ancestors_except_self = ancestors
+          ancestors_except_self.delete(self)
+          ancestors_except_self.each do |ancestor|
+            if ancestor.respond_to?(method_name, true)
+              return ancestor.send(method_name)
+            end
+          end
+          default_value
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/finder.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # Find schema members using string paths
+    #
+    # @example Finding object types
+    #   MySchema.find("SomeObjectType")
+    #
+    # @example Finding fields
+    #   MySchema.find("SomeObjectType.myField")
+    #
+    # @example Finding arguments
+    #   MySchema.find("SomeObjectType.myField.anArgument")
+    #
+    # @example Finding directives
+    #   MySchema.find("@include")
+    #
+    class Finder
+      class MemberNotFoundError < ArgumentError; end
+
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def find(path)
+        path = path.split(".")
+        type_or_directive = path.shift
+
+        if type_or_directive.start_with?("@")
+          directive = schema.directives[type_or_directive[1..-1]]
+
+          if directive.nil?
+            raise MemberNotFoundError, "Could not find directive `#{type_or_directive}` in schema."
+          end
+
+          return directive if path.empty?
+
+          find_in_directive(directive, path: path)
+        else
+          type = schema.get_type(type_or_directive) # rubocop:disable Development/ContextIsPassedCop -- build-time
+
+          if type.nil?
+            raise MemberNotFoundError, "Could not find type `#{type_or_directive}` in schema."
+          end
+
+          return type if path.empty?
+
+          find_in_type(type, path: path)
+        end
+      end
+
+      private
+
+      attr_reader :schema
+
+      def find_in_directive(directive, path:)
+        argument_name = path.shift
+        argument = directive.get_argument(argument_name) # rubocop:disable Development/ContextIsPassedCop -- build-time
+
+        if argument.nil?
+          raise MemberNotFoundError, "Could not find argument `#{argument_name}` on directive #{directive}."
+        end
+
+        argument
+      end
+
+      def find_in_type(type, path:)
+        case type.kind.name
+        when "OBJECT"
+          find_in_fields_type(type, kind: "object", path: path)
+        when "INTERFACE"
+          find_in_fields_type(type, kind: "interface", path: path)
+        when "INPUT_OBJECT"
+          find_in_input_object(type, path: path)
+        when "UNION"
+          # Error out if path that was provided is too long
+          # i.e UnionType.PossibleType.aField
+          # Use PossibleType.aField instead.
+          if invalid = path.first
+            raise MemberNotFoundError, "Cannot select union possible type `#{invalid}`. Select the type directly instead."
+          end
+        when "ENUM"
+          find_in_enum_type(type, path: path)
+        else
+          raise "Unexpected find_in_type: #{type.inspect} (#{path})"
+        end
+      end
+
+      def find_in_fields_type(type, kind:, path:)
+        field_name = path.shift
+        field = schema.get_field(type, field_name)
+
+        if field.nil?
+          raise MemberNotFoundError, "Could not find field `#{field_name}` on #{kind} type `#{type.graphql_name}`."
+        end
+
+        return field if path.empty?
+
+        find_in_field(field, path: path)
+      end
+
+      def find_in_field(field, path:)
+        argument_name = path.shift
+        argument = field.get_argument(argument_name) # rubocop:disable Development/ContextIsPassedCop -- build-time
+
+        if argument.nil?
+          raise MemberNotFoundError, "Could not find argument `#{argument_name}` on field `#{field.name}`."
+        end
+
+        # Error out if path that was provided is too long
+        # i.e Type.field.argument.somethingBad
+        if invalid = path.first
+          raise MemberNotFoundError, "Cannot select member `#{invalid}` on a field."
+        end
+
+        argument
+      end
+
+      def find_in_input_object(input_object, path:)
+        field_name = path.shift
+        input_field = input_object.get_argument(field_name) # rubocop:disable Development/ContextIsPassedCop -- build-time
+
+        if input_field.nil?
+          raise MemberNotFoundError, "Could not find input field `#{field_name}` on input object type `#{input_object.graphql_name}`."
+        end
+
+        # Error out if path that was provided is too long
+        # i.e InputType.inputField.bad
+        if invalid = path.first
+          raise MemberNotFoundError, "Cannot select member `#{invalid}` on an input field."
+        end
+
+        input_field
+      end
+
+      def find_in_enum_type(enum_type, path:)
+        value_name = path.shift
+        enum_value = enum_type.enum_values.find { |v| v.graphql_name == value_name } # rubocop:disable Development/ContextIsPassedCop -- build-time, not runtime
+
+        if enum_value.nil?
+          raise MemberNotFoundError, "Could not find enum value `#{value_name}` on enum type `#{enum_type.graphql_name}`."
+        end
+
+        # Error out if path that was provided is too long
+        # i.e Enum.VALUE.wat
+        if invalid = path.first
+          raise MemberNotFoundError, "Cannot select member `#{invalid}` on an enum value."
+        end
+
+        enum_value
+      end
+    end
+  end
+end

data/lib/graphql/schema/input_object.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class InputObject < GraphQL::Schema::Member
+      extend Forwardable
+      extend GraphQL::Schema::Member::HasArguments
+      extend GraphQL::Schema::Member::HasArguments::ArgumentObjectLoader
+      extend GraphQL::Schema::Member::ValidatesInput
+      extend GraphQL::Schema::Member::HasValidators
+
+      include GraphQL::Dig
+
+      # @return [GraphQL::Query::Context] The context for this query
+      attr_reader :context
+      # @return [GraphQL::Execution::Interpereter::Arguments] The underlying arguments instance
+      attr_reader :arguments
+
+      # Ruby-like hash behaviors, read-only
+      def_delegators :@ruby_style_hash, :keys, :values, :each, :map, :any?, :empty?
+
+      def initialize(arguments, ruby_kwargs:, context:, defaults_used:)
+        @context = context
+        @ruby_style_hash = ruby_kwargs
+        @arguments = arguments
+        # Apply prepares, not great to have it duplicated here.
+        self.class.arguments(context).each_value do |arg_defn|
+          ruby_kwargs_key = arg_defn.keyword
+          if @ruby_style_hash.key?(ruby_kwargs_key)
+            # Weirdly, procs are applied during coercion, but not methods.
+            # Probably because these methods require a `self`.
+            if arg_defn.prepare.is_a?(Symbol) || context.nil?
+              prepared_value = arg_defn.prepare_value(self, @ruby_style_hash[ruby_kwargs_key])
+              overwrite_argument(ruby_kwargs_key, prepared_value)
+            end
+          end
+        end
+      end
+
+      def to_h
+        unwrap_value(@ruby_style_hash)
+      end
+
+      def to_hash
+        to_h
+      end
+
+      def prepare
+        if @context
+          object = @context[:current_object]
+          # Pass this object's class with `as` so that messages are rendered correctly from inherited validators
+          Schema::Validator.validate!(self.class.validators, object, @context, @ruby_style_hash, as: self.class)
+          self
+        else
+          self
+        end
+      end
+
+      def self.authorized?(obj, value, ctx)
+        # Authorize each argument (but this doesn't apply if `prepare` is implemented):
+        if value.respond_to?(:key?)
+          arguments(ctx).each do |_name, input_obj_arg|
+            if value.key?(input_obj_arg.keyword) &&
+              !input_obj_arg.authorized?(obj, value[input_obj_arg.keyword], ctx)
+              return false
+            end
+          end
+        end
+        # It didn't early-return false:
+        true
+      end
+
+      def self.one_of
+        if !one_of?
+          if all_argument_definitions.any? { |arg| arg.type.non_null? }
+            raise ArgumentError, "`one_of` may not be used with required arguments -- add `required: false` to argument definitions to use `one_of`"
+          end
+          directive(GraphQL::Schema::Directive::OneOf)
+        end
+      end
+
+      def self.one_of?
+        directives.any? { |d| d.is_a?(GraphQL::Schema::Directive::OneOf) }
+      end
+
+      def unwrap_value(value)
+        case value
+        when Array
+          value.map { |item| unwrap_value(item) }
+        when Hash
+          value.reduce({}) do |h, (key, value)|
+            h.merge!(key => unwrap_value(value))
+          end
+        when InputObject
+          value.to_h
+        else
+          value
+        end
+      end
+
+      # Lookup a key on this object, it accepts new-style underscored symbols
+      # Or old-style camelized identifiers.
+      # @param key [Symbol, String]
+      def [](key)
+        if @ruby_style_hash.key?(key)
+          @ruby_style_hash[key]
+        elsif @arguments
+          @arguments[key]
+        else
+          nil
+        end
+      end
+
+      def key?(key)
+        @ruby_style_hash.key?(key) || (@arguments && @arguments.key?(key)) || false
+      end
+
+      # A copy of the Ruby-style hash
+      def to_kwargs
+        @ruby_style_hash.dup
+      end
+
+      class << self
+        def argument(*args, **kwargs, &block)
+          argument_defn = super(*args, **kwargs, &block)
+          if one_of?
+            if argument_defn.type.non_null?
+              raise ArgumentError, "Argument '#{argument_defn.path}' must be nullable because it is part of a OneOf type, add `required: false`."
+            end
+            if argument_defn.default_value?
+              raise ArgumentError, "Argument '#{argument_defn.path}' cannot have a default value because it is part of a OneOf type, remove `default_value: ...`."
+            end
+          end
+          # Add a method access
+          method_name = argument_defn.keyword
+          class_eval <<-RUBY, __FILE__, __LINE__
+            def #{method_name}
+              self[#{method_name.inspect}]
+            end
+          RUBY
+          argument_defn
+        end
+
+        def kind
+          GraphQL::TypeKinds::INPUT_OBJECT
+        end
+
+        # @api private
+        INVALID_OBJECT_MESSAGE = "Expected %{object} to be a key-value object responding to `to_h` or `to_unsafe_h`."
+
+        def validate_non_null_input(input, ctx, max_errors: nil)
+          warden = ctx.warden
+
+          if input.is_a?(Array)
+            return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
+          end
+
+          if !(input.respond_to?(:to_h) || input.respond_to?(:to_unsafe_h))
+            # We're not sure it'll act like a hash, so reject it:
+            return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
+          end
+
+          # Inject missing required arguments
+          missing_required_inputs = self.arguments(ctx).reduce({}) do |m, (argument_name, argument)|
+            if !input.key?(argument_name) && argument.type.non_null? && warden.get_argument(self, argument_name)
+              m[argument_name] = nil
+            end
+
+            m
+          end
+
+          result = nil
+          [input, missing_required_inputs].each do |args_to_validate|
+            args_to_validate.each do |argument_name, value|
+              argument = warden.get_argument(self, argument_name)
+              # Items in the input that are unexpected
+              if argument.nil?
+                result ||= Query::InputValidationResult.new
+                result.add_problem("Field is not defined on #{self.graphql_name}", [argument_name])
+              else
+                # Items in the input that are expected, but have invalid values
+                argument_result = argument.type.validate_input(value, ctx)
+                result ||= Query::InputValidationResult.new
+                if !argument_result.valid?
+                  result.merge_result!(argument_name, argument_result)
+                end
+              end
+            end
+          end
+
+          if one_of?
+            if input.size == 1
+              input.each do |name, value|
+                if value.nil?
+                  result ||= Query::InputValidationResult.new
+                  result.add_problem("'#{graphql_name}' requires exactly one argument, but '#{name}' was `null`.")
+                end
+              end
+            else
+              result ||= Query::InputValidationResult.new
+              result.add_problem("'#{graphql_name}' requires exactly one argument, but #{input.size} were provided.")
+            end
+          end
+
+          result
+        end
+
+        def coerce_input(value, ctx)
+          if value.nil?
+            return nil
+          end
+
+          arguments = coerce_arguments(nil, value, ctx)
+
+          ctx.schema.after_lazy(arguments) do |resolved_arguments|
+            if resolved_arguments.is_a?(GraphQL::Error)
+              raise resolved_arguments
+            else
+              input_obj_instance = self.new(resolved_arguments, ruby_kwargs: resolved_arguments.keyword_arguments, context: ctx, defaults_used: nil)
+              input_obj_instance.prepare
+            end
+          end
+        end
+
+        # It's funny to think of a _result_ of an input object.
+        # This is used for rendering the default value in introspection responses.
+        def coerce_result(value, ctx)
+          # Allow the application to provide values as :snake_symbols, and convert them to the camelStrings
+          value = value.reduce({}) { |memo, (k, v)| memo[Member::BuildType.camelize(k.to_s)] = v; memo }
+
+          result = {}
+
+          arguments(ctx).each do |input_key, input_field_defn|
+            input_value = value[input_key]
+            if value.key?(input_key)
+              result[input_key] = if input_value.nil?
+                nil
+              else
+                input_field_defn.type.coerce_result(input_value, ctx)
+              end
+            end
+          end
+
+          result
+        end
+      end
+
+      private
+
+      def overwrite_argument(key, value)
+        # Argument keywords come in frozen from the interpreter, dup them before modifying them.
+        if @ruby_style_hash.frozen?
+          @ruby_style_hash = @ruby_style_hash.dup
+        end
+        @ruby_style_hash[key] = value
+      end
+    end
+  end
+end