graphql_cody 1.13.0

data/lib/graphql/query/fingerprint.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'digest/sha2'
+
+module GraphQL
+  class Query
+    # @api private
+    # @see Query#query_fingerprint
+    # @see Query#variables_fingerprint
+    # @see Query#fingerprint
+    module Fingerprint
+      # Make an obfuscated hash of the given string (either a query string or variables JSON)
+      # @param string [String]
+      # @return [String] A normalized, opaque hash
+      def self.generate(input_str)
+        # Implemented to be:
+        # - Short (and uniform) length
+        # - Stable
+        # - Irreversibly Opaque (don't want to leak variable values)
+        # - URL-friendly
+        bytes = Digest::SHA256.digest(input_str)
+        Base64.urlsafe_encode64(bytes)
+      end
+    end
+  end
+end

data/lib/graphql/query/input_validation_result.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    class InputValidationResult
+      attr_accessor :problems
+
+      def initialize(valid: true, problems: nil)
+        @valid = valid
+        @problems = problems
+      end
+
+      def valid?
+        @valid
+      end
+
+      def add_problem(explanation, path = nil, extensions: nil, message: nil)
+        @problems ||= []
+        @valid = false
+        problem = { "path" => path || [], "explanation" => explanation }
+        if extensions
+          problem["extensions"] = extensions
+        end
+        if message
+          problem["message"] = message
+        end
+        @problems.push(problem)
+      end
+
+      def merge_result!(path, inner_result)
+        return if inner_result.valid?
+
+        if inner_result.problems
+          inner_result.problems.each do |p|
+            item_path = [path, *p["path"]]
+            add_problem(p["explanation"], item_path, message: p["message"], extensions: p["extensions"])
+          end
+        end
+        # It could have been explicitly set on inner_result (if it had no problems)
+        @valid = false
+      end
+    end
+  end
+end

data/lib/graphql/query/literal_input.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    # Turn query string values into something useful for query execution
+    class LiteralInput
+      def self.coerce(type, ast_node, variables)
+        case ast_node
+        when nil
+          nil
+        when Language::Nodes::NullValue
+          nil
+        when Language::Nodes::VariableIdentifier
+          variables[ast_node.name]
+        else
+          case type.kind.name
+          when "SCALAR"
+            # TODO smell
+            # This gets used for plain values during subscriber.trigger
+            if variables
+              type.coerce_input(ast_node, variables.context)
+            else
+              type.coerce_isolated_input(ast_node)
+            end
+          when "ENUM"
+            # TODO smell
+            # This gets used for plain values sometimes
+            v = ast_node.is_a?(GraphQL::Language::Nodes::Enum) ? ast_node.name : ast_node
+            if variables
+              type.coerce_input(v, variables.context)
+            else
+              type.coerce_isolated_input(v)
+            end
+          when "NON_NULL"
+            LiteralInput.coerce(type.of_type, ast_node, variables)
+          when "LIST"
+            if ast_node.is_a?(Array)
+              ast_node.map { |element_ast| LiteralInput.coerce(type.of_type, element_ast, variables) }
+            else
+              [LiteralInput.coerce(type.of_type, ast_node, variables)]
+            end
+          when "INPUT_OBJECT"
+            # TODO smell: handling AST vs handling plain Ruby
+            next_args = ast_node.is_a?(Hash) ? ast_node : ast_node.arguments
+            from_arguments(next_args, type, variables)
+          else
+            raise "Invariant: unexpected type to coerce to: #{type}"
+          end
+        end
+      end
+
+      def self.from_arguments(ast_arguments, argument_owner, variables)
+        context = variables ? variables.context : nil
+        values_hash = {}
+        defaults_used = Set.new
+
+        indexed_arguments = case ast_arguments
+        when Hash
+          ast_arguments
+        when Array
+          ast_arguments.each_with_object({}) { |a, memo| memo[a.name] = a }
+        else
+          raise ArgumentError, "Unexpected ast_arguments: #{ast_arguments}"
+        end
+
+        argument_defns = argument_owner.arguments(context || GraphQL::Query::NullContext)
+        argument_defns.each do |arg_name, arg_defn|
+          ast_arg = indexed_arguments[arg_name]
+          # First, check the argument in the AST.
+          # If the value is a variable,
+          # only add a value if the variable is actually present.
+          # Otherwise, coerce the value in the AST, prepare the value and add it.
+          #
+          # TODO: since indexed_arguments can come from a plain Ruby hash,
+          # have to check for `false` or `nil` as hash values. This is getting smelly :S
+          if indexed_arguments.key?(arg_name)
+            arg_value = ast_arg.is_a?(GraphQL::Language::Nodes::Argument) ? ast_arg.value : ast_arg
+
+            value_is_a_variable = arg_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+
+            if (!value_is_a_variable || (value_is_a_variable && variables.key?(arg_value.name)))
+
+              value = coerce(arg_defn.type, arg_value, variables)
+              # Legacy `prepare` application
+              if arg_defn.is_a?(GraphQL::Argument)
+                value = arg_defn.prepare(value, context)
+              end
+
+              if value.is_a?(GraphQL::ExecutionError)
+                value.ast_node = ast_arg
+                raise value
+              end
+
+              values_hash[arg_name] = value
+            end
+          end
+
+          # Then, the definition for a default value.
+          # If the definition has a default value and
+          # a value wasn't provided from the AST,
+          # then add the default value.
+          if arg_defn.default_value? && !values_hash.key?(arg_name)
+            value = arg_defn.default_value
+            defaults_used << arg_name
+            # `context` isn't present when pre-calculating defaults
+            if context
+              if arg_defn.is_a?(GraphQL::Argument)
+                value = arg_defn.prepare(value, context)
+              end
+              if value.is_a?(GraphQL::ExecutionError)
+                value.ast_node = ast_arg
+                raise value
+              end
+            end
+            values_hash[arg_name] = value
+          end
+        end
+
+        if argument_owner.is_a?(Class) || argument_owner.is_a?(GraphQL::Schema::Field)
+          # A Schema::InputObject, Schema::GraphQL::Field, Schema::Directive, logic from Query::Arguments#to_kwargs
+          ruby_kwargs = {}
+          values_hash.each do |key, value|
+            ruby_kwargs[Schema::Member::BuildType.underscore(key).to_sym] = value
+          end
+          if argument_owner.is_a?(Class) && argument_owner < GraphQL::Schema::InputObject
+            argument_owner.new(ruby_kwargs: ruby_kwargs, context: context, defaults_used: defaults_used)
+          else
+            ruby_kwargs
+          end
+        else
+          result = argument_owner.arguments_class.new(values_hash, context: context, defaults_used: defaults_used)
+          result.prepare
+        end
+      end
+    end
+  end
+end

data/lib/graphql/query/null_context.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    # This object can be `ctx` in places where there is no query
+    class NullContext
+      class NullWarden < GraphQL::Schema::Warden
+        def visible_field?(field, ctx); true; end
+        def visible_argument?(arg, ctx); true; end
+        def visible_type?(type, ctx); true; end
+        def visible_enum_value?(ev, ctx); true; end
+        def visible_type_membership?(tm, ctx); true; end
+      end
+
+      class NullQuery
+        def with_error_handling
+          yield
+        end
+      end
+
+      class NullSchema < GraphQL::Schema
+      end
+
+      attr_reader :schema, :query, :warden, :dataloader
+
+      def initialize
+        @query = NullQuery.new
+        @dataloader = GraphQL::Dataloader::NullDataloader.new
+        @schema = NullSchema
+        @warden = NullWarden.new(
+          GraphQL::Filter.new,
+          context: self,
+          schema: @schema,
+        )
+      end
+
+      def [](key); end
+
+      def interpreter?
+        true
+      end
+
+      class << self
+        extend Forwardable
+
+        def [](key); end
+
+        def instance
+          @instance ||= self.new
+        end
+
+        def_delegators :instance, :query, :warden, :schema, :interpreter?, :dataloader
+      end
+    end
+  end
+end

data/lib/graphql/query/result.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Query
+    # A result from {Schema#execute}.
+    # It provides the requested data and
+    # access to the {Query} and {Query::Context}.
+    class Result
+      extend Forwardable
+
+      def initialize(query:, values:)
+        @query = query
+        @to_h = values
+      end
+
+      # @return [GraphQL::Query] The query that was executed
+      attr_reader :query
+
+      # @return [Hash] The resulting hash of "data" and/or "errors"
+      attr_reader :to_h
+
+      def_delegators :@query, :context, :mutation?, :query?, :subscription?
+
+      def_delegators :@to_h, :[], :keys, :values, :to_json, :as_json
+
+      # Delegate any hash-like method to the underlying hash.
+      def method_missing(method_name, *args, &block)
+        if @to_h.respond_to?(method_name)
+          @to_h.public_send(method_name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @to_h.respond_to?(method_name) || super
+      end
+
+      def inspect
+        "#<GraphQL::Query::Result @query=... @to_h=#{@to_h}>"
+      end
+
+      # A result is equal to another object when:
+      #
+      # - The other object is a Hash whose value matches `result.to_h`
+      # - The other object is a Result whose value matches `result.to_h`
+      #
+      # (The query is ignored for comparing result equality.)
+      #
+      # @return [Boolean]
+      def ==(other)
+        case other
+        when Hash
+          @to_h == other
+        when Query::Result
+          @to_h == other.to_h
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/graphql/query/serial_execution/field_resolution.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    class SerialExecution
+      class FieldResolution
+        attr_reader :irep_node, :parent_type, :target, :field, :arguments, :query
+
+        def initialize(selection, parent_type, target, query_ctx)
+          @irep_node = selection
+          @selection = selection
+          @parent_type = parent_type
+          @target = target
+          @query = query_ctx.query
+          @field = irep_node.definition
+          @field_ctx = query_ctx.spawn_child(
+            key: irep_node.name,
+            object: target,
+            irep_node: irep_node,
+          )
+          @arguments = @query.arguments_for(irep_node, @field)
+        end
+
+        def result
+          result_name = irep_node.name
+          raw_value = get_raw_value
+          if raw_value.is_a?(GraphQL::Execution::Execute::Skip)
+            {}
+          else
+            { result_name => get_finished_value(raw_value) }
+          end
+        end
+
+        # GraphQL::Batch depends on this
+        def execution_context
+          @field_ctx
+        end
+
+        private
+
+        # After getting the value from the field's resolve method,
+        # continue by "finishing" the value, eg. executing sub-fields or coercing values
+        def get_finished_value(raw_value)
+          case raw_value
+          when GraphQL::ExecutionError
+            raw_value.ast_node = @field_ctx.ast_node
+            raw_value.path = @field_ctx.path
+            @query.context.errors.push(raw_value)
+          when Array
+            list_errors = raw_value.each_with_index.select { |value, _| value.is_a?(GraphQL::ExecutionError) }
+            if list_errors.any?
+              list_errors.each do |error, index|
+                error.ast_node = @field_ctx.ast_node
+                error.path = @field_ctx.path + [index]
+                @query.context.errors.push(error)
+              end
+            end
+          end
+
+          begin
+            GraphQL::Query::SerialExecution::ValueResolution.resolve(
+              parent_type,
+              field,
+              field.type,
+              raw_value,
+              @selection,
+              @field_ctx,
+            )
+          rescue GraphQL::Query::Executor::PropagateNull
+            if field.type.kind.non_null?
+              raise
+            else
+              nil
+            end
+          end
+        end
+
+        # Get the result of:
+        # - Any middleware on this schema
+        # - The field's resolve method
+        # If the middleware chain returns a GraphQL::ExecutionError, its message
+        # is added to the "errors" key.
+        def get_raw_value
+          begin
+            @field_ctx.schema.middleware.invoke([parent_type, target, field, arguments, @field_ctx]) # rubocop:disable Development/ContextIsPassedCop -- unrelated
+          rescue GraphQL::ExecutionError => err
+            err
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/query/serial_execution/operation_resolution.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    class SerialExecution
+      module OperationResolution
+        def self.resolve(selection, target, query)
+          result = query.context.execution_strategy.selection_resolution.resolve(
+            query.root_value,
+            target,
+            selection,
+            query.context,
+          )
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/graphql/query/serial_execution/selection_resolution.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    class SerialExecution
+      module SelectionResolution
+        def self.resolve(target, current_type, selection, query_ctx)
+          selection_result = {}
+
+          selection.typed_children[current_type].each do |name, subselection|
+            selection_result.merge!(query_ctx.execution_strategy.field_resolution.new(
+              subselection,
+              current_type,
+              target,
+              query_ctx
+            ).result)
+          end
+
+          selection_result
+        end
+      end
+    end
+  end
+end

data/lib/graphql/query/serial_execution/value_resolution.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    class SerialExecution
+      module ValueResolution
+        def self.resolve(parent_type, field_defn, field_type, value, selection, query_ctx)
+          if value.nil? || value.is_a?(GraphQL::ExecutionError)
+            if field_type.kind.non_null?
+              if value.nil?
+                type_error = GraphQL::InvalidNullError.new(parent_type, field_defn, value)
+                query_ctx.schema.type_error(type_error, query_ctx)
+              end
+              raise GraphQL::Query::Executor::PropagateNull
+            else
+              nil
+            end
+          else
+            case field_type.kind
+            when GraphQL::TypeKinds::SCALAR, GraphQL::TypeKinds::ENUM
+              field_type.coerce_result(value, query_ctx)
+            when GraphQL::TypeKinds::LIST
+              wrapped_type = field_type.of_type
+              result = []
+              i = 0
+              value.each do |inner_value|
+                inner_ctx = query_ctx.spawn_child(
+                  key: i,
+                  object: inner_value,
+                  irep_node: selection,
+                )
+
+                result << resolve(
+                  parent_type,
+                  field_defn,
+                  wrapped_type,
+                  inner_value,
+                  selection,
+                  inner_ctx,
+                )
+                i += 1
+              end
+              result
+            when GraphQL::TypeKinds::NON_NULL
+              wrapped_type = field_type.of_type
+              resolve(
+                parent_type,
+                field_defn,
+                wrapped_type,
+                value,
+                selection,
+                query_ctx,
+              )
+            when GraphQL::TypeKinds::OBJECT
+              query_ctx.execution_strategy.selection_resolution.resolve(
+                value,
+                field_type,
+                selection,
+                query_ctx
+              )
+            when GraphQL::TypeKinds::UNION, GraphQL::TypeKinds::INTERFACE
+              query = query_ctx.query
+              resolved_type = query.resolve_type(value)
+              possible_types = query.possible_types(field_type)
+
+              if !possible_types.include?(resolved_type)
+                type_error = GraphQL::UnresolvedTypeError.new(value, field_defn, parent_type, resolved_type, possible_types)
+                query.schema.type_error(type_error, query_ctx)
+                raise GraphQL::Query::Executor::PropagateNull
+              else
+                resolve(
+                  parent_type,
+                  field_defn,
+                  resolved_type,
+                  value,
+                  selection,
+                  query_ctx,
+                )
+              end
+            else
+              raise("Unknown type kind: #{field_type.kind}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/query/serial_execution.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require "graphql/query/serial_execution/value_resolution"
+require "graphql/query/serial_execution/field_resolution"
+require "graphql/query/serial_execution/operation_resolution"
+require "graphql/query/serial_execution/selection_resolution"
+
+module GraphQL
+  class Query
+    class SerialExecution
+      # This is the only required method for an Execution strategy.
+      # You could create a custom execution strategy and configure your schema to
+      # use that custom strategy instead.
+      #
+      # @param ast_operation [GraphQL::Language::Nodes::OperationDefinition] The operation definition to run
+      # @param root_type [GraphQL::ObjectType] either the query type or the mutation type
+      # @param query_object [GraphQL::Query] the query object for this execution
+      # @return [Hash] a spec-compliant GraphQL result, as a hash
+      def execute(ast_operation, root_type, query_object)
+        GraphQL::Deprecation.warn "#{self.class} will be removed in GraphQL-Ruby 2.0, please upgrade to the Interpreter: https://graphql-ruby.org/queries/interpreter.html"
+        operation_resolution.resolve(
+          query_object.irep_selection,
+          root_type,
+          query_object
+        )
+      end
+
+      def field_resolution
+        self.class::FieldResolution
+      end
+
+      def operation_resolution
+        self.class::OperationResolution
+      end
+
+      def selection_resolution
+        self.class::SelectionResolution
+      end
+    end
+  end
+end