graphql_cody 1.13.0

data/lib/graphql/pagination/sequel_dataset_connection.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require "graphql/pagination/relation_connection"
+
+module GraphQL
+  module Pagination
+    # Customizes `RelationConnection` to work with `Sequel::Dataset`s.
+    class SequelDatasetConnection < Pagination::RelationConnection
+      private
+
+      def relation_offset(relation)
+        relation.opts[:offset]
+      end
+
+      def relation_limit(relation)
+        relation.opts[:limit]
+      end
+
+      def relation_count(relation)
+        # Remove order to make it faster
+        relation.order(nil).count
+      end
+
+      def null_relation(relation)
+        relation.where(false)
+      end
+    end
+  end
+end

data/lib/graphql/pagination.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+require "graphql/pagination/array_connection"
+require "graphql/pagination/active_record_relation_connection"
+require "graphql/pagination/connections"
+require "graphql/pagination/mongoid_relation_connection"
+require "graphql/pagination/sequel_dataset_connection"

data/lib/graphql/parse_error.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module GraphQL
+  class ParseError < GraphQL::Error
+    attr_reader :line, :col, :query
+    def initialize(message, line, col, query, filename: nil)
+      if filename
+        message += " (#{filename})"
+      end
+
+      super(message)
+      @line = line
+      @col = col
+      @query = query
+    end
+
+    def to_h
+      locations = line ? [{ "line" => line, "column" => col }] : []
+      {
+        "message" => message,
+        "locations" => locations,
+      }
+    end
+  end
+end

data/lib/graphql/query/arguments.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    # Read-only access to values, normalizing all keys to strings
+    #
+    # {Arguments} recursively wraps the input in {Arguments} instances.
+    class Arguments
+      extend Forwardable
+      include GraphQL::Dig
+
+      def self.construct_arguments_class(argument_owner)
+        argument_definitions = argument_owner.arguments # rubocop:disable Development/ContextIsPassedCop -- legacy-related
+        argument_owner.arguments_class = Class.new(self) do
+          self.argument_owner = argument_owner
+          self.argument_definitions = argument_definitions
+
+          argument_definitions.each do |_arg_name, arg_definition|
+            if arg_definition.method_access?
+              expose_as = arg_definition.expose_as.to_s.freeze
+              expose_as_underscored = GraphQL::Schema::Member::BuildType.underscore(expose_as).freeze
+              method_names = [expose_as, expose_as_underscored].uniq
+              method_names.each do |method_name|
+                # Don't define a helper method if it would override something.
+                if method_defined?(method_name)
+                  GraphQL::Deprecation.warn(
+                    "Unable to define a helper for argument with name '#{method_name}' "\
+                    "as this is a reserved name. Add `method_access: false` to stop this warning."
+                  )
+                else
+                  define_method(method_name) do
+                    # Always use `expose_as` here, since #[] doesn't accept underscored names
+                    self[expose_as]
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      attr_reader :argument_values
+
+      def initialize(values, context:, defaults_used:)
+        @argument_values = values.inject({}) do |memo, (inner_key, inner_value)|
+          arg_name = inner_key.to_s
+          arg_defn = self.class.argument_definitions[arg_name] || raise("Not found #{arg_name} among #{self.class.argument_definitions.keys}")
+          arg_default_used = defaults_used.include?(arg_name)
+          arg_value = wrap_value(inner_value, arg_defn.type, context)
+          string_key = arg_defn.expose_as
+          memo[string_key] = ArgumentValue.new(string_key, arg_value, arg_defn, arg_default_used)
+          memo
+        end
+      end
+
+      # @param key [String, Symbol] name or index of value to access
+      # @return [Object] the argument at that key
+      def [](key)
+        key_s = key.is_a?(String) ? key : key.to_s
+        @argument_values.fetch(key_s, NULL_ARGUMENT_VALUE).value
+      end
+
+      # @param key [String, Symbol] name of value to access
+      # @return [Boolean] true if the argument was present in this field
+      def key?(key)
+        key_s = key.is_a?(String) ? key : key.to_s
+        @argument_values.key?(key_s)
+      end
+
+      # @param key [String, Symbol] name of value to access
+      # @return [Boolean] true if the argument default was passed as the argument value to the resolver
+      def default_used?(key)
+        key_s = key.is_a?(String) ? key : key.to_s
+        @argument_values.fetch(key_s, NULL_ARGUMENT_VALUE).default_used?
+      end
+
+      # Get the hash of all values, with stringified keys
+      # @return [Hash] the stringified hash
+      def to_h
+        @to_h ||= begin
+          h = {}
+          each_value do |arg_value|
+            arg_key = arg_value.definition.expose_as
+            h[arg_key] = unwrap_value(arg_value.value)
+          end
+          h
+        end
+      end
+
+      def_delegators :to_h, :keys, :values, :each
+      def_delegators :@argument_values, :any?
+
+      def prepare
+        self
+      end
+
+      # Access each key, value and type for the arguments in this set.
+      # @yield [argument_value] The {ArgumentValue} for each argument
+      # @yieldparam argument_value [ArgumentValue]
+      def each_value
+        @argument_values.each_value do |argument_value|
+          yield(argument_value)
+        end
+      end
+
+      class << self
+        attr_accessor :argument_definitions, :argument_owner
+      end
+
+      NoArguments = Class.new(self) do
+        self.argument_definitions = []
+      end
+
+      NO_ARGS = NoArguments.new({}, context: nil, defaults_used: Set.new)
+
+      # Convert this instance into valid Ruby keyword arguments
+      # @return [{Symbol=>Object}]
+      def to_kwargs
+        ruby_kwargs = {}
+
+        keys.each do |key|
+          ruby_kwargs[Schema::Member::BuildType.underscore(key).to_sym] = self[key]
+        end
+
+        ruby_kwargs
+      end
+
+      alias :to_hash :to_kwargs
+
+      private
+
+      class ArgumentValue
+        attr_reader :key, :value, :definition
+        attr_writer :default_used
+
+        def initialize(key, value, definition, default_used)
+          @key = key
+          @value = value
+          @definition = definition
+          @default_used = default_used
+        end
+
+        # @return [Boolean] true if the argument default was passed as the argument value to the resolver
+        def default_used?
+          @default_used
+        end
+      end
+
+      NULL_ARGUMENT_VALUE = ArgumentValue.new(nil, nil, nil, nil)
+
+      def wrap_value(value, arg_defn_type, context)
+        if value.nil?
+          nil
+        else
+          case arg_defn_type
+          when GraphQL::ListType
+            value.map { |item| wrap_value(item, arg_defn_type.of_type, context) }
+          when GraphQL::NonNullType
+            wrap_value(value, arg_defn_type.of_type, context)
+          when GraphQL::InputObjectType
+            if value.is_a?(Hash)
+              result = arg_defn_type.arguments_class.new(value, context: context, defaults_used: Set.new)
+              result.prepare
+            else
+              value
+            end
+          else
+            value
+          end
+        end
+      end
+
+      def unwrap_value(value)
+        case value
+        when Array
+          value.map { |item| unwrap_value(item) }
+        when Hash
+          value.inject({}) do |memo, (key, value)|
+            memo[key] = unwrap_value(value)
+            memo
+          end
+        when GraphQL::Query::Arguments, GraphQL::Schema::InputObject
+          value.to_h
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/graphql/query/arguments_cache.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    module ArgumentsCache
+      # @return [Hash<InternalRepresentation::Node, GraphQL::Language::NodesDirectiveNode => Hash<GraphQL::Field, GraphQL::Directive => GraphQL::Query::Arguments>>]
+      def self.build(query)
+        Hash.new do |h1, irep_or_ast_node|
+          h1[irep_or_ast_node] = Hash.new do |h2, definition|
+            ast_node = irep_or_ast_node.is_a?(GraphQL::InternalRepresentation::Node) ? irep_or_ast_node.ast_node : irep_or_ast_node
+            h2[definition] = if definition.arguments(query.context).empty?
+              GraphQL::Query::Arguments::NO_ARGS
+            else
+              GraphQL::Query::LiteralInput.from_arguments(
+                ast_node.arguments,
+                definition,
+                query.variables,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/query/context.rb

@@ -0,0 +1,371 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    # Expose some query-specific info to field resolve functions.
+    # It delegates `[]` to the hash that's passed to `GraphQL::Query#initialize`.
+    class Context
+      module SharedMethods
+        # @return [Object] The target for field resolution
+        attr_accessor :object
+
+        # @return [Hash, Array, String, Integer, Float, Boolean, nil] The resolved value for this field
+        attr_reader :value
+
+        # @return [Boolean] were any fields of this selection skipped?
+        attr_reader :skipped
+        alias :skipped? :skipped
+
+        # @api private
+        attr_writer :skipped
+
+        # Return this value to tell the runtime
+        # to exclude this field from the response altogether
+        def skip
+          GraphQL::Execution::Execute::SKIP
+        end
+
+        # @return [Boolean] True if this selection has been nullified by a null child
+        def invalid_null?
+          @invalid_null
+        end
+
+        # Remove this child from the result value
+        # (used for null propagation and skip)
+        # @api private
+        def delete_child(child_ctx)
+          @value.delete(child_ctx.key)
+        end
+
+        # Create a child context to use for `key`
+        # @param key [String, Integer] The key in the response (name or index)
+        # @param irep_node [InternalRepresentation::Node] The node being evaluated
+        # @api private
+        def spawn_child(key:, irep_node:, object:)
+          FieldResolutionContext.new(
+            @context,
+            key,
+            irep_node,
+            self,
+            object
+          )
+        end
+
+        # Add error at query-level.
+        # @param error [GraphQL::ExecutionError] an execution error
+        # @return [void]
+        def add_error(error)
+          if !error.is_a?(ExecutionError)
+            raise TypeError, "expected error to be a ExecutionError, but was #{error.class}"
+          end
+          errors << error
+          nil
+        end
+
+        # @example Print the GraphQL backtrace during field resolution
+        #   puts ctx.backtrace
+        #
+        # @return [GraphQL::Backtrace] The backtrace for this point in query execution
+        def backtrace
+          GraphQL::Backtrace.new(self)
+        end
+
+        def execution_errors
+          @execution_errors ||= ExecutionErrors.new(self)
+        end
+
+        def lookahead
+          ast_nodes = irep_node.ast_nodes
+          field = irep_node.definition.metadata[:type_class] || raise("Lookahead is only compatible with class-based schemas")
+          Execution::Lookahead.new(query: query, ast_nodes: ast_nodes, field: field)
+        end
+      end
+
+      class ExecutionErrors
+        def initialize(ctx)
+          @context = ctx
+        end
+
+        def add(err_or_msg)
+          err = case err_or_msg
+          when String
+            GraphQL::ExecutionError.new(err_or_msg)
+          when GraphQL::ExecutionError
+            err_or_msg
+          else
+            raise ArgumentError, "expected String or GraphQL::ExecutionError, not #{err_or_msg.class} (#{err_or_msg.inspect})"
+          end
+          # This will assign ast_node and path
+          @context.add_error(err)
+        end
+
+        alias :>> :add
+        alias :push :add
+      end
+
+      include SharedMethods
+      extend Forwardable
+
+      attr_reader :execution_strategy
+      # `strategy` is required by GraphQL::Batch
+      alias_method :strategy, :execution_strategy
+
+      def execution_strategy=(new_strategy)
+        # GraphQL::Batch re-assigns this value but it was previously not used
+        # (ExecutionContext#strategy was used instead)
+        # now it _is_ used, but it breaks GraphQL::Batch tests
+        @execution_strategy ||= new_strategy
+      end
+
+      # @return [GraphQL::InternalRepresentation::Node] The internal representation for this query node
+      def irep_node
+        @irep_node ||= query.irep_selection
+      end
+
+      # @return [GraphQL::Language::Nodes::Field] The AST node for the currently-executing field
+      def ast_node
+        @irep_node.ast_node
+      end
+
+      # @return [Array<GraphQL::ExecutionError>] errors returned during execution
+      attr_reader :errors
+
+      # @return [GraphQL::Query] The query whose context this is
+      attr_reader :query
+
+      # @return [GraphQL::Schema]
+      attr_reader :schema
+
+      # @return [Array<String, Integer>] The current position in the result
+      attr_reader :path
+
+      # Make a new context which delegates key lookup to `values`
+      # @param query [GraphQL::Query] the query who owns this context
+      # @param values [Hash] A hash of arbitrary values which will be accessible at query-time
+      def initialize(query:, schema: query.schema, values:, object:)
+        @query = query
+        @schema = schema
+        @provided_values = values || {}
+        @object = object
+        # Namespaced storage, where user-provided values are in `nil` namespace:
+        @storage = Hash.new { |h, k| h[k] = {} }
+        @storage[nil] = @provided_values
+        @errors = []
+        @path = []
+        @value = nil
+        @context = self # for SharedMethods
+        @scoped_context = {}
+      end
+
+      def dataloader
+        @dataloader ||= self[:dataloader] || (query.multiplex ? query.multiplex.dataloader : schema.dataloader_class.new)
+      end
+
+      # @api private
+      attr_writer :interpreter
+
+      # @api private
+      attr_writer :value
+
+      # @api private
+      attr_accessor :scoped_context
+
+      def []=(key, value)
+        @provided_values[key] = value
+      end
+
+      def_delegators :@query, :trace, :interpreter?
+
+      # @!method []=(key, value)
+      #   Reassign `key` to the hash passed to {Schema#execute} as `context:`
+
+      # Lookup `key` from the hash passed to {Schema#execute} as `context:`
+      def [](key)
+        return @scoped_context[key] if @scoped_context.key?(key)
+        @provided_values[key]
+      end
+
+      def delete(key)
+        if @scoped_context.key?(key)
+          @scoped_context.delete(key)
+        else
+          @provided_values.delete(key)
+        end
+      end
+
+      UNSPECIFIED_FETCH_DEFAULT = Object.new
+
+      def fetch(key, default = UNSPECIFIED_FETCH_DEFAULT)
+        if @scoped_context.key?(key)
+          @scoped_context[key]
+        elsif @provided_values.key?(key)
+          @provided_values[key]
+        elsif default != UNSPECIFIED_FETCH_DEFAULT
+          default
+        elsif block_given?
+          yield(self, key)
+        else
+          raise KeyError.new(key: key)
+        end
+      end
+
+      def dig(key, *other_keys)
+        @scoped_context.key?(key) ? @scoped_context.dig(key, *other_keys) : @provided_values.dig(key, *other_keys)
+      end
+
+      def to_h
+        @provided_values.merge(@scoped_context)
+      end
+      alias :to_hash :to_h
+
+      def key?(key)
+        @scoped_context.key?(key) || @provided_values.key?(key)
+      end
+
+      # @return [GraphQL::Schema::Warden]
+      def warden
+        @warden ||= (@query && @query.warden)
+      end
+
+      # @api private
+      attr_writer :warden
+
+      # Get an isolated hash for `ns`. Doesn't affect user-provided storage.
+      # @param ns [Object] a usage-specific namespace identifier
+      # @return [Hash] namespaced storage
+      def namespace(ns)
+        @storage[ns]
+      end
+
+      def inspect
+        "#<Query::Context ...>"
+      end
+
+      # @api private
+      def received_null_child
+        @invalid_null = true
+        @value = nil
+      end
+
+      def scoped_merge!(hash)
+        @scoped_context = @scoped_context.merge(hash)
+      end
+
+      def scoped_set!(key, value)
+        scoped_merge!(key => value)
+        nil
+      end
+
+      class FieldResolutionContext
+        include SharedMethods
+        include Tracing::Traceable
+        extend Forwardable
+
+        attr_reader :irep_node, :field, :parent_type, :query, :schema, :parent, :key, :type
+        alias :selection :irep_node
+
+        def initialize(context, key, irep_node, parent, object)
+          @context = context
+          @key = key
+          @parent = parent
+          @object = object
+          @irep_node = irep_node
+          @field = irep_node.definition
+          @parent_type = irep_node.owner_type
+          @type = field.type
+          # This is needed constantly, so set it ahead of time:
+          @query = context.query
+          @schema = context.schema
+          @tracers = @query.tracers
+          # This hack flag is required by ConnectionResolve
+          @wrapped_connection = false
+          @wrapped_object = false
+        end
+
+        # @api private
+        attr_accessor :wrapped_connection, :wrapped_object
+
+        def path
+          @path ||= @parent.path.dup << @key
+        end
+
+        def_delegators :@context,
+          :[], :[]=, :key?, :fetch, :to_h, :namespace, :dig,
+          :spawn, :warden, :errors,
+          :execution_strategy, :strategy, :interpreter?
+
+        # @return [GraphQL::Language::Nodes::Field] The AST node for the currently-executing field
+        def ast_node
+          @irep_node.ast_node
+        end
+
+        # Add error to current field resolution.
+        # @param error [GraphQL::ExecutionError] an execution error
+        # @return [void]
+        def add_error(error)
+          super
+          error.ast_node ||= irep_node.ast_node
+          error.path ||= path
+          nil
+        end
+
+        def inspect
+          "#<GraphQL Context @ #{irep_node.owner_type.name}.#{field.name}>"
+        end
+
+        # Set a new value for this field in the response.
+        # It may be updated after resolving a {Lazy}.
+        # If it is {Execute::PROPAGATE_NULL}, tell the owner to propagate null.
+        # If it's {Execute::Execution::SKIP}, remove this field result from its parent
+        # @param new_value [Any] The GraphQL-ready value
+        # @api private
+        def value=(new_value)
+          case new_value
+          when GraphQL::Execution::Execute::PROPAGATE_NULL, nil
+            @invalid_null = true
+            @value = nil
+            if @type.kind.non_null?
+              @parent.received_null_child
+            end
+          when GraphQL::Execution::Execute::SKIP
+            @parent.skipped = true
+            @parent.delete_child(self)
+          else
+            @value = new_value
+          end
+        end
+
+        protected
+
+        def received_null_child
+          case @value
+          when Hash
+            self.value = GraphQL::Execution::Execute::PROPAGATE_NULL
+          when Array
+            if list_of_non_null_items?(@type)
+              self.value = GraphQL::Execution::Execute::PROPAGATE_NULL
+            end
+          when nil
+            # TODO This is a hack
+            # It was already nulled out but it's getting reassigned
+          else
+            raise "Unexpected value for received_null_child (#{self.value.class}): #{value}"
+          end
+        end
+
+        private
+
+        def list_of_non_null_items?(type)
+          case type
+          when GraphQL::NonNullType
+            # Unwrap [T]!
+            list_of_non_null_items?(type.of_type)
+          when GraphQL::ListType
+            type.of_type.is_a?(GraphQL::NonNullType)
+          else
+            raise "Unexpected list_of_non_null_items check: #{type}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/query/executor.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+module GraphQL
+  class Query
+    class Executor
+      class PropagateNull < StandardError; end
+
+      # @return [GraphQL::Query] the query being executed
+      attr_reader :query
+
+      def initialize(query)
+        @query = query
+      end
+
+      # Evaluate {operation_name} on {query}.
+      # Handle {GraphQL::ExecutionError}s by putting them in the "errors" key.
+      # @return [Hash] A GraphQL response, with either a "data" key or an "errors" key
+      def result
+        execute
+      rescue GraphQL::ExecutionError => err
+        query.context.errors << err
+        {"errors" => [err.to_h]}
+      end
+
+      private
+
+      def execute
+        operation = query.selected_operation
+        return {} if operation.nil?
+
+        op_type = operation.operation_type
+        root_type = query.root_type_for_operation(op_type)
+        execution_strategy_class = query.schema.execution_strategy_for_operation(op_type)
+        execution_strategy = execution_strategy_class.new
+
+        query.context.execution_strategy = execution_strategy
+        data_result = begin
+          execution_strategy.execute(operation, root_type, query)
+        rescue PropagateNull
+          nil
+        end
+        result = { "data" => data_result }
+        error_result = query.context.errors.map(&:to_h)
+
+        if error_result.any?
+          result["errors"] = error_result
+        end
+
+        result
+      end
+    end
+  end
+end