graphql_cody 1.13.0

data/lib/graphql/schema/argument.rb

@@ -0,0 +1,383 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Argument
+      include GraphQL::Schema::Member::CachedGraphQLDefinition
+      include GraphQL::Schema::Member::AcceptsDefinition
+      include GraphQL::Schema::Member::HasPath
+      include GraphQL::Schema::Member::HasAstNode
+      include GraphQL::Schema::Member::HasDirectives
+      include GraphQL::Schema::Member::HasDeprecationReason
+      include GraphQL::Schema::Member::HasValidators
+      include GraphQL::Schema::FindInheritedValue::EmptyObjects
+
+      NO_DEFAULT = :__no_default__
+
+      # @return [String] the GraphQL name for this argument, camelized unless `camelize: false` is provided
+      attr_reader :name
+      alias :graphql_name :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
+
+      # @return [Class, Module, nil] If this argument should load an application object, this is the type of object to load
+      attr_reader :loads
+
+      # @return [Boolean] true if a resolver defined this argument
+      def from_resolver?
+        @from_resolver
+      end
+
+      # @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 transform this argument's valuebefore sending it to field resolution
+      # @param camelize [Boolean] if true, the name will be camelized when building the schema
+      # @param from_resolver [Boolean] if true, a Resolver class defined this argument
+      # @param method_access [Boolean] If false, don't build method access on legacy {Query::Arguments} instances.
+      # @param directives [Hash{Class => Hash}]
+      # @param deprecation_reason [String]
+      # @param validates [Hash, nil] Options for building validators, if any should be applied
+      def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, method_access: true, owner:, validates: nil, directives: nil, deprecation_reason: nil, &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
+        @loads = loads
+        @keyword = as || (arg_name.is_a?(Symbol) ? arg_name : Schema::Member::BuildType.underscore(@name).to_sym)
+        @prepare = prepare
+        @ast_node = ast_node
+        @from_resolver = from_resolver
+        @method_access = method_access
+        self.deprecation_reason = deprecation_reason
+
+        if directives
+          directives.each do |dir_class, dir_options|
+            directive(dir_class, **dir_options)
+          end
+        end
+
+        self.validates(validates)
+
+        if definition_block
+          if definition_block.arity == 1
+            instance_exec(self, &definition_block)
+          else
+            instance_eval(&definition_block)
+          end
+        end
+      end
+
+      def inspect
+        "#<#{self.class} #{path}: #{type.to_type_signature}#{description ? " @description=#{description.inspect}" : ""}>"
+      end
+
+      # @return [Object] the value used when the client doesn't provide a value for this argument
+      attr_reader :default_value
+
+      # @return [Boolean] True if this argument has a default value
+      def default_value?
+        @default_value != NO_DEFAULT
+      end
+
+      attr_writer :description
+
+      # @return [String] Documentation for this argument
+      def description(text = nil)
+        if text
+          @description = text
+        else
+          @description
+        end
+      end
+
+      # @return [String] Deprecation reason for this argument
+      def deprecation_reason(text = nil)
+        if text
+          self.deprecation_reason = text
+        else
+          super()
+        end
+      end
+
+      def deprecation_reason=(new_reason)
+        validate_deprecated_or_optional(null: @null, deprecation_reason: new_reason)
+        super
+      end
+
+      def visible?(context)
+        true
+      end
+
+      def accessible?(context)
+        true
+      end
+
+      def authorized?(obj, value, ctx)
+        authorized_as_type?(obj, value, ctx, as_type: type)
+      end
+
+      def authorized_as_type?(obj, value, ctx, as_type:)
+        if value.nil?
+          return true
+        end
+
+        if as_type.kind.non_null?
+          as_type = as_type.of_type
+        end
+
+        if as_type.kind.list?
+          value.each do |v|
+            if !authorized_as_type?(obj, v, ctx, as_type: as_type.of_type)
+              return false
+            end
+          end
+        elsif as_type.kind.input_object?
+          as_type.arguments(ctx).each do |_name, input_obj_arg|
+            input_obj_arg = input_obj_arg.type_class
+            # TODO: this skips input objects whose values were alread replaced with application objects.
+            # See: https://github.com/rmosolgo/graphql-ruby/issues/2633
+            if value.is_a?(InputObject) && value.key?(input_obj_arg.keyword) && !input_obj_arg.authorized?(obj, value[input_obj_arg.keyword], ctx)
+              return false
+            end
+          end
+        end
+        # None of the early-return conditions were activated,
+        # so this is authorized.
+        true
+      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
+        argument.ast_node = ast_node
+        argument.method_access = @method_access
+        if NO_DEFAULT != @default_value
+          argument.default_value = @default_value
+        end
+        if self.deprecation_reason
+          argument.deprecation_reason = self.deprecation_reason
+        end
+        argument
+      end
+
+      def type=(new_type)
+        validate_input_type(new_type)
+        # This isn't true for LateBoundTypes, but we can assume those will
+        # be updated via this codepath later in schema setup.
+        if new_type.respond_to?(:non_null?)
+          validate_deprecated_or_optional(null: !new_type.non_null?, deprecation_reason: deprecation_reason)
+        end
+        @type = new_type
+      end
+
+      def type
+        @type ||= begin
+          parsed_type = begin
+            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
+          # Use the setter method to get validations
+          self.type = parsed_type
+        end
+      end
+
+      def statically_coercible?
+        return @statically_coercible if defined?(@statically_coercible)
+
+        @statically_coercible = !@prepare.is_a?(String) && !@prepare.is_a?(Symbol)
+      end
+
+      # Apply the {prepare} configuration to `value`, using methods from `obj`.
+      # Used by the runtime.
+      # @api private
+      def prepare_value(obj, value, context: nil)
+        if value.is_a?(GraphQL::Schema::InputObject)
+          value = value.prepare
+        end
+
+        Schema::Validator.validate!(validators, obj, context, value)
+
+        if @prepare.nil?
+          value
+        elsif @prepare.is_a?(String) || @prepare.is_a?(Symbol)
+          if obj.nil?
+            # The problem here is, we _used to_ prepare while building variables.
+            # But now we don't have the runtime object there.
+            #
+            # This will have to be called later, when the runtime object _is_ available.
+            value
+          else
+            obj.public_send(@prepare, value)
+          end
+        elsif @prepare.respond_to?(:call)
+          @prepare.call(value, context || obj.context)
+        else
+          raise "Invalid prepare for #{@owner.name}.name: #{@prepare.inspect}"
+        end
+      end
+
+      # @api private
+      def coerce_into_values(parent_object, values, context, argument_values)
+        arg_name = graphql_name
+        arg_key = keyword
+        default_used = false
+
+        if values.key?(arg_name)
+          value = values[arg_name]
+        elsif values.key?(arg_key)
+          value = values[arg_key]
+        elsif default_value?
+          value = default_value
+          default_used = true
+        else
+          # no value at all
+          owner.validate_directive_argument(self, nil)
+          return
+        end
+
+        loaded_value = nil
+        coerced_value = context.schema.error_handler.with_error_handling(context) do
+          type.coerce_input(value, context)
+        end
+
+        # If this isn't lazy, then the block returns eagerly and assigns the result here
+        # If it _is_ lazy, then we write the lazy to the hash, then update it later
+        argument_values[arg_key] = context.schema.after_lazy(coerced_value) do |resolved_coerced_value|
+          if loads && !from_resolver?
+            loaded_value = context.query.with_error_handling do
+              load_and_authorize_value(owner, coerced_value, context)
+            end
+          end
+
+          maybe_loaded_value = loaded_value || resolved_coerced_value
+          context.schema.after_lazy(maybe_loaded_value) do |resolved_loaded_value|
+            owner.validate_directive_argument(self, resolved_loaded_value)
+            prepared_value = context.schema.error_handler.with_error_handling(context) do
+              prepare_value(parent_object, resolved_loaded_value, context: context)
+            end
+
+            # TODO code smell to access such a deeply-nested constant in a distant module
+            argument_values[arg_key] = GraphQL::Execution::Interpreter::ArgumentValue.new(
+              value: prepared_value,
+              definition: self,
+              default_used: default_used,
+            )
+          end
+        end
+      end
+
+      def load_and_authorize_value(load_method_owner, coerced_value, context)
+        if coerced_value.nil?
+          return nil
+        end
+        arg_load_method = "load_#{keyword}"
+        if load_method_owner.respond_to?(arg_load_method)
+          custom_loaded_value = if load_method_owner.is_a?(Class)
+            load_method_owner.public_send(arg_load_method, coerced_value, context)
+          else
+            load_method_owner.public_send(arg_load_method, coerced_value)
+          end
+          context.schema.after_lazy(custom_loaded_value) do |custom_value|
+            if loads
+              if type.list?
+                loaded_values = custom_value.each_with_index.map { |custom_val, idx|
+                  id = coerced_value[idx]
+                  load_method_owner.authorize_application_object(self, id, context, custom_val)
+                }
+                context.schema.after_any_lazies(loaded_values, &:itself)
+              else
+                load_method_owner.authorize_application_object(self, coerced_value, context, custom_loaded_value)
+              end
+            else
+              custom_value
+            end
+          end
+        elsif loads
+          if type.list?
+            loaded_values = coerced_value.map { |val| load_method_owner.load_and_authorize_application_object(self, val, context) }
+            context.schema.after_any_lazies(loaded_values, &:itself)
+          else
+            load_method_owner.load_and_authorize_application_object(self, coerced_value, context)
+          end
+        else
+          coerced_value
+        end
+      end
+
+      # @api private
+      def validate_default_value
+        coerced_default_value = begin
+          # This is weird, but we should accept single-item default values for list-type arguments.
+          # If we used `coerce_isolated_input` below, it would do this for us, but it's not really
+          # the right thing here because we expect default values in application format (Ruby values)
+          # not GraphQL format (scalar values).
+          #
+          # But I don't think Schema::List#coerce_result should apply wrapping to single-item lists.
+          prepped_default_value = if default_value.nil?
+            nil
+          elsif (type.kind.list? || (type.kind.non_null? && type.of_type.list?)) && !default_value.respond_to?(:map)
+            [default_value]
+          else
+            default_value
+          end
+
+          type.coerce_isolated_result(prepped_default_value) unless prepped_default_value.nil?
+        rescue GraphQL::Schema::Enum::UnresolvedValueError
+          # It raises this, which is helpful at runtime, but not here...
+          default_value
+        end
+        res = type.valid_isolated_input?(coerced_default_value)
+        if !res
+          raise InvalidDefaultValueError.new(self)
+        end
+      end
+
+      class InvalidDefaultValueError < GraphQL::Error
+        def initialize(argument)
+          message = "`#{argument.path}` has an invalid default value: `#{argument.default_value.inspect}` isn't accepted by `#{argument.type.to_type_signature}`; update the default value or the argument type."
+          super(message)
+        end
+      end
+
+      private
+
+      def validate_input_type(input_type)
+        if input_type.is_a?(String) || input_type.is_a?(GraphQL::Schema::LateBoundType)
+          # Do nothing; assume this will be validated later
+        elsif input_type.kind.non_null? || input_type.kind.list?
+          validate_input_type(input_type.unwrap)
+        elsif !input_type.kind.input?
+          raise ArgumentError, "Invalid input type for #{path}: #{input_type.graphql_name}. Must be scalar, enum, or input object, not #{input_type.kind.name}."
+        else
+          # It's an input type, we're OK
+        end
+      end
+
+      def validate_deprecated_or_optional(null:, deprecation_reason:)
+        if deprecation_reason && !null
+          raise ArgumentError, "Required arguments cannot be deprecated: #{path}."
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/base_64_bp.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+# backport from ruby v2.5 to v2.2 that has no `padding` things
+# @api private
+module Base64Bp
+  extend Base64
+
+  module_function
+
+  def urlsafe_encode64(bin, padding:)
+    str = strict_encode64(bin)
+    str.tr!("+/", "-_")
+    str.delete!("=") unless padding
+    str
+  end
+
+  def urlsafe_decode64(str)
+    str = str.tr("-_", "+/")
+    if !str.end_with?("=") && str.length % 4 != 0
+      str = str.ljust((str.length + 3) & ~3, "=")
+    end
+    strict_decode64(str)
+  end
+end

data/lib/graphql/schema/base_64_encoder.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'graphql/schema/base_64_bp'
+
+module GraphQL
+  class Schema
+    # @api private
+    module Base64Encoder
+      def self.encode(unencoded_text, nonce: false)
+        Base64Bp.urlsafe_encode64(unencoded_text, padding: false)
+      end
+
+      def self.decode(encoded_text, nonce: false)
+        # urlsafe_decode64 is for forward compatibility
+        Base64Bp.urlsafe_decode64(encoded_text)
+      rescue ArgumentError
+        raise GraphQL::ExecutionError, "Invalid input: #{encoded_text.inspect}"
+      end
+    end
+  end
+end

data/lib/graphql/schema/build_from_definition/resolve_map/default_resolve.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    module BuildFromDefinition
+      class ResolveMap
+        class DefaultResolve
+          def initialize(field_map, field_name)
+            @field_map = field_map
+            @field_name = field_name
+          end
+
+          # Make some runtime checks about
+          # how `obj` implements the `field_name`.
+          #
+          # Create a new resolve function according to that implementation, then:
+          #   - update `field_map` with this implementation
+          #   - call the implementation now (to satisfy this field execution)
+          #
+          # If `obj` doesn't implement `field_name`, raise an error.
+          def call(obj, args, ctx)
+            method_name = @field_name
+            if !obj.respond_to?(method_name)
+              raise KeyError, "Can't resolve field #{method_name} on #{obj.inspect}"
+            else
+              method_arity = obj.method(method_name).arity
+              resolver = case method_arity
+              when 0, -1
+                # -1 Handles method_missing, eg openstruct
+                ->(o, a, c) { o.public_send(method_name) }
+              when 1
+                ->(o, a, c) { o.public_send(method_name, a) }
+              when 2
+                ->(o, a, c) { o.public_send(method_name, a, c) }
+              else
+                raise "Unexpected resolve arity: #{method_arity}. Must be 0, 1, 2"
+              end
+              # Call the resolver directly next time
+              @field_map[method_name] = resolver
+              # Call through this time
+              resolver.call(obj, args, ctx)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/build_from_definition/resolve_map.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+require "graphql/schema/build_from_definition/resolve_map/default_resolve"
+
+module GraphQL
+  class Schema
+    module BuildFromDefinition
+      # Wrap a user-provided hash of resolution behavior for easy access at runtime.
+      #
+      # Coerce scalar values by:
+      # - Checking for a function in the map like `{ Date: { coerce_input: ->(val, ctx) { ... }, coerce_result: ->(val, ctx) { ... } } }`
+      # - Falling back to a passthrough
+      #
+      # Interface/union resolution can be provided as a `resolve_type:` key.
+      #
+      # @api private
+      class ResolveMap
+        module NullScalarCoerce
+          def self.call(val, _ctx)
+            val
+          end
+        end
+
+        def initialize(user_resolve_hash)
+          @resolve_hash = Hash.new do |h, k|
+            # For each type name, provide a new hash if one wasn't given:
+            h[k] = Hash.new do |h2, k2|
+              if k2 == "coerce_input" || k2 == "coerce_result"
+                # This isn't an object field, it's a scalar coerce function.
+                # Use a passthrough
+                NullScalarCoerce
+              else
+                # For each field, provide a resolver that will
+                # make runtime checks & replace itself
+                h2[k2] = DefaultResolve.new(h2, k2)
+              end
+            end
+          end
+          @user_resolve_hash = user_resolve_hash
+          # User-provided resolve functions take priority over the default:
+          @user_resolve_hash.each do |type_name, fields|
+            type_name_s = type_name.to_s
+            case fields
+            when Hash
+              fields.each do |field_name, resolve_fn|
+                @resolve_hash[type_name_s][field_name.to_s] = resolve_fn
+              end
+            when Proc
+              # for example, "resolve_type"
+              @resolve_hash[type_name_s] = fields
+            else
+              raise ArgumentError, "Unexpected resolve hash value for #{type_name.inspect}: #{fields.inspect} (#{fields.class})"
+            end
+          end
+
+          # Check the normalized hash, not the user input:
+          if @resolve_hash.key?("resolve_type")
+            define_singleton_method :resolve_type do |type, obj, ctx|
+              @resolve_hash.fetch("resolve_type").call(type, obj, ctx)
+            end
+          end
+        end
+
+        def call(type, field, obj, args, ctx)
+          resolver = @resolve_hash[type.graphql_name][field.graphql_name]
+          resolver.call(obj, args, ctx)
+        end
+
+        def coerce_input(type, value, ctx)
+          @resolve_hash[type.graphql_name]["coerce_input"].call(value, ctx)
+        end
+
+        def coerce_result(type, value, ctx)
+          @resolve_hash[type.graphql_name]["coerce_result"].call(value, ctx)
+        end
+      end
+    end
+  end
+end