graphql 0.16.0 → 2.0.15

data/lib/graphql/analysis/analyze_query.rb

@@ -1,73 +0,0 @@
-module GraphQL
-  module Analysis
-    module_function
-    # Visit `query`'s internal representation, calling `analyzers` along the way.
-    #
-    # - First, query analyzers are initialized by calling `.initial_value(query)`, if they respond to that method.
-    # - Then, they receive `.call(memo, visit_type, irep_node)`, where visit type is `:enter` or `:leave`.
-    # - Last, they receive `.final_value(memo)`, if they respond to that method.
-    #
-    # It returns an array of final `memo` values in the order that `analyzers` were passed in.
-    #
-    # @param query [GraphQL::Query]
-    # @param analyzers [Array<#call>] Objects that respond to `#call(memo, visit_type, irep_node)`
-    # @return [Array<Any>] Results from those analyzers
-    def analyze_query(query, analyzers)
-      analyzers_and_values = analyzers.map { |r| initialize_reducer(r, query) }
-
-      irep = query.internal_representation
-
-      irep.each do |name, op_node|
-        reduce_node(op_node, analyzers_and_values)
-      end
-
-      analyzers_and_values.map { |(r, value)| finalize_reducer(r, value) }
-    end
-
-    private
-
-    module_function
-
-    # Enter the node, visit its children, then leave the node.
-    def reduce_node(irep_node, analyzers_and_values)
-      visit_analyzers(:enter, irep_node, analyzers_and_values)
-
-      irep_node.children.each do |name, child_irep_node|
-        reduce_node(child_irep_node, analyzers_and_values)
-      end
-
-      visit_analyzers(:leave, irep_node, analyzers_and_values)
-    end
-
-    def visit_analyzers(visit_type, irep_node, analyzers_and_values)
-      analyzers_and_values.each do |reducer_and_value|
-        reducer = reducer_and_value[0]
-        memo = reducer_and_value[1]
-        next_memo = reducer.call(memo, visit_type, irep_node)
-        reducer_and_value[1] = next_memo
-      end
-    end
-
-    # If the reducer has an `initial_value` method, call it and store
-    # the result as `memo`. Otherwise, use `nil` as memo.
-    # @return [Array<(#call, Any)>] reducer-memo pairs
-    def initialize_reducer(reducer, query)
-      if reducer.respond_to?(:initial_value)
-        [reducer, reducer.initial_value(query)]
-      else
-        [reducer, nil]
-      end
-    end
-
-    # If the reducer accepts `final_value`, send it the last memo value.
-    # Otherwise, use the last value from the traversal.
-    # @return [Any] final memo value
-    def finalize_reducer(reducer, reduced_value)
-      if reducer.respond_to?(:final_value)
-        reducer.final_value(reduced_value)
-      else
-        reduced_value
-      end
-    end
-  end
-end

data/lib/graphql/analysis/max_query_complexity.rb

@@ -1,25 +0,0 @@
-require_relative "./query_complexity"
-module GraphQL
-  module Analysis
-    # Used under the hood to implement complexity validation,
-    # see {Schema#max_complexity} and {Query#max_complexity}
-    #
-    # @example Assert max complexity of 10
-    #   # DON'T actually do this, graphql-ruby
-    #   # Does this for you based on your `max_complexity` setting
-    #   MySchema.query_analyzers << GraphQL::Analysis::MaxQueryComplexity.new(10)
-    #
-    class MaxQueryComplexity < GraphQL::Analysis::QueryComplexity
-      def initialize(max_complexity)
-        disallow_excessive_complexity = -> (query, complexity) {
-          if complexity > max_complexity
-            GraphQL::AnalysisError.new("Query has complexity of #{complexity}, which exceeds max complexity of #{max_complexity}")
-          else
-            nil
-          end
-        }
-        super(&disallow_excessive_complexity)
-      end
-    end
-  end
-end

data/lib/graphql/analysis/max_query_depth.rb

@@ -1,25 +0,0 @@
-require_relative "./query_depth"
-module GraphQL
-  module Analysis
-    # Used under the hood to implement depth validation,
-    # see {Schema#max_depth} and {Query#max_depth}
-    #
-    # @example Assert max depth of 10
-    #   # DON'T actually do this, graphql-ruby
-    #   # Does this for you based on your `max_depth` setting
-    #   MySchema.query_analyzers << GraphQL::Analysis::MaxQueryDepth.new(10)
-    #
-    class MaxQueryDepth < GraphQL::Analysis::QueryDepth
-      def initialize(max_depth)
-        disallow_excessive_depth = -> (query, depth) {
-          if depth > max_depth
-            GraphQL::AnalysisError.new("Query has depth of #{depth}, which exceeds max depth of #{max_depth}")
-          else
-            nil
-          end
-        }
-        super(&disallow_excessive_depth)
-      end
-    end
-  end
-end

data/lib/graphql/analysis/query_complexity.rb

@@ -1,122 +0,0 @@
-module GraphQL
-  module Analysis
-    # Calculate the complexity of a query, using {Field#complexity} values.
-    #
-    # @example Log the complexity of incoming queries
-    #   MySchema.query_analyzers << GraphQL::AnalysisQueryComplexity.new do |query, complexity|
-    #     Rails.logger.info("Complexity: #{complexity}")
-    #   end
-    #
-    class QueryComplexity
-      # @yield [query, complexity] Called for each query analyzed by the schema, before executing it
-      # @yieldparam query [GraphQL::Query] The query that was analyzed
-      # @yieldparam complexity [Numeric] The complexity for this query
-      def initialize(&block)
-        @complexity_handler = block
-      end
-
-      # State for the query complexity calcuation:
-      # - `query` is needed for variables, then passed to handler
-      # - `complexities_on_type` holds complexity scores for each type in an IRep node
-      def initial_value(query)
-        {
-          query: query,
-          complexities_on_type: [TypeComplexity.new],
-        }
-      end
-
-      # Implement the query analyzer API
-      def call(memo, visit_type, irep_node)
-        if irep_node.ast_node.is_a?(GraphQL::Language::Nodes::Field)
-          if visit_type == :enter
-            memo[:complexities_on_type].push(TypeComplexity.new)
-          else
-            type_complexities = memo[:complexities_on_type].pop
-            own_complexity = if GraphQL::Query::DirectiveResolution.include_node?(irep_node, memo[:query])
-              child_complexity = type_complexities.max_possible_complexity
-              get_complexity(irep_node, memo[:query], child_complexity)
-            else
-              0
-            end
-            memo[:complexities_on_type].last.merge(irep_node.on_types, own_complexity)
-          end
-        end
-        memo
-      end
-
-      # Send the query and complexity to the block
-      # @return [Object, GraphQL::AnalysisError] Whatever the handler returns
-      def final_value(reduced_value)
-        total_complexity = reduced_value[:complexities_on_type].pop.max_possible_complexity
-        @complexity_handler.call(reduced_value[:query], total_complexity)
-      end
-
-      private
-
-      # Get a complexity value for a field,
-      # by getting the number or calling its proc
-      def get_complexity(irep_node, query, child_complexity)
-        field_defn = irep_node.definition
-        defined_complexity = field_defn.complexity
-        case defined_complexity
-        when Proc
-          args = query.arguments_for(irep_node)
-          defined_complexity.call(query.context, args, child_complexity)
-        when Numeric
-          defined_complexity + (child_complexity || 0)
-        else
-          raise("Invalid complexity: #{defined_complexity.inspect} on #{field_defn.name}")
-        end
-      end
-
-      # Selections on an object may apply differently depending on what is _actually_ returned by the resolve function.
-      # Find the maximum possible complexity among those combinations.
-      class TypeComplexity
-        def initialize
-          @types = Hash.new { |h, k| h[k] = 0 }
-        end
-
-        # Return the max possible complexity for types in this selection
-        def max_possible_complexity
-          max_complexity = 0
-
-          @types.each do |type_defn, own_complexity|
-            type_complexity = @types.reduce(0) do |memo, (other_type, other_complexity)|
-              if types_overlap?(type_defn, other_type)
-                memo + other_complexity
-              else
-                memo
-              end
-            end
-
-            if type_complexity > max_complexity
-              max_complexity = type_complexity
-            end
-          end
-          max_complexity
-        end
-
-        # Store the complexity score for each of `types`
-        def merge(types, complexity)
-          types.each { |t| @types[t] += complexity }
-        end
-
-        private
-        # True if:
-        # - type_1 is type_2
-        # - type_1 is a member of type_2's possible types
-        def types_overlap?(type_1, type_2)
-          if type_1 == type_2
-            true
-          elsif type_2.kind.union?
-            type_2.include?(type_1)
-          elsif type_1.kind.object? && type_2.kind.interface?
-            type_1.interfaces.include?(type_2)
-          else
-            false
-          end
-        end
-      end
-    end
-  end
-end

data/lib/graphql/analysis/query_depth.rb

@@ -1,54 +0,0 @@
-module GraphQL
-  module Analysis
-    # A query reducer for measuring the depth of a given query.
-    #
-    # @example Logging the depth of a query
-    #   Schema.query_analyzers << GraphQL::Analysis::QueryDepth.new { |depth|  puts "GraphQL query depth: #{depth}" }
-    #   Schema.execute(query_str)
-    #   # GraphQL query depth: 8
-    #
-    class QueryDepth
-      def initialize(&block)
-        @depth_handler = block
-      end
-
-      def initial_value(query)
-        {
-          max_depth: 0,
-          current_depth: 0,
-          skip_current_scope: false,
-          query: query,
-        }
-      end
-
-      def call(memo, visit_type, irep_node)
-        if irep_node.ast_node.is_a?(GraphQL::Language::Nodes::Field)
-          if visit_type == :enter
-            if GraphQL::Schema::DYNAMIC_FIELDS.include?(irep_node.definition.name)
-              # Don't validate introspection fields
-              memo[:skip_current_scope] = true
-            elsif memo[:skip_current_scope]
-              # we're inside an introspection query
-            elsif GraphQL::Query::DirectiveResolution.include_node?(irep_node, memo[:query])
-              memo[:current_depth] += 1
-            end
-          else
-            if GraphQL::Schema::DYNAMIC_FIELDS.include?(irep_node.definition.name)
-              memo[:skip_current_scope] = false
-            elsif GraphQL::Query::DirectiveResolution.include_node?(irep_node, memo[:query])
-              if memo[:max_depth] < memo[:current_depth]
-                memo[:max_depth] = memo[:current_depth]
-              end
-              memo[:current_depth] -= 1
-            end
-          end
-        end
-        memo
-      end
-
-      def final_value(memo)
-        @depth_handler.call(memo[:query], memo[:max_depth])
-      end
-    end
-  end
-end

data/lib/graphql/argument.rb

@@ -1,25 +0,0 @@
-module GraphQL
-  # Used for defined arguments ({Field}, {InputObjectType})
-  #
-  # {#name} must be a String.
-  #
-  # @example defining an argument for a field
-  #   GraphQL::Field.define do
-  #     # ...
-  #     argument :favoriteFood, types.String, "Favorite thing to eat", default_value: "pizza"
-  #   end
-  #
-  # @example defining an input field for an {InputObjectType}
-  #   GraphQL::InputObjectType.define do
-  #     input_field :newName, !types.String
-  #   end
-  #
-  class Argument
-    include GraphQL::Define::InstanceDefinable
-    accepts_definitions :name, :type, :description, :default_value
-    attr_accessor :type, :description, :default_value
-
-    # @return [String] The name of this argument on its {GraphQL::Field} or {GraphQL::InputObjectType}
-    attr_accessor :name
-  end
-end

data/lib/graphql/base_type.rb

@@ -1,115 +0,0 @@
-module GraphQL
-  # The parent for all type classes.
-  class BaseType
-    include GraphQL::Define::NonNullWithBang
-    include GraphQL::Define::InstanceDefinable
-    attr_accessor :name, :description
-    accepts_definitions :name, :description
-
-    # @param other [GraphQL::BaseType] compare to this object
-    # @return [Boolean] are these types equivalent? (incl. non-null, list)
-    def ==(other)
-      if other.is_a?(GraphQL::BaseType)
-        self.to_s == other.to_s
-      else
-        super
-      end
-    end
-
-    # If this type is modifying an underlying type,
-    # return the underlying type. (Otherwise, return `self`.)
-    def unwrap
-      self
-    end
-
-    # @return [GraphQL::NonNullType] a non-null version of this type
-    def to_non_null_type
-      GraphQL::NonNullType.new(of_type: self)
-    end
-
-    # @return [GraphQL::ListType] a list version of this type
-    def to_list_type
-      GraphQL::ListType.new(of_type: self)
-    end
-
-    module ModifiesAnotherType
-      def unwrap
-        self.of_type.unwrap
-      end
-    end
-
-    # Find out which possible type to use for `value`.
-    # Returns self if there are no possible types (ie, not Union or Interface)
-    def resolve_type(value)
-      self
-    end
-
-    module HasPossibleTypes
-      # Return the implementing type for `object`.
-      # The default implementation assumes that there's a type with the same name as `object.class.name`.
-      # Maybe you'll need to override this in your own interfaces!
-      #
-      # @param object [Object] the object which needs a type to expose it
-      # @param ctx [GraphQL::Query::Context]
-      # @return [GraphQL::ObjectType] the type which should expose `object`
-      def resolve_type(object, ctx)
-        instance_exec(object, ctx, &(@resolve_type_proc || DEFAULT_RESOLVE_TYPE))
-      end
-
-      # The default implementation of {#resolve_type} gets `object.class.name`
-      # and finds a type with the same name
-      DEFAULT_RESOLVE_TYPE = -> (object, ctx) {
-        type_name = object.class.name
-        ctx.schema.possible_types(self).find {|t| t.name == type_name}
-      }
-
-      def resolve_type=(new_proc)
-        @resolve_type_proc = new_proc || DEFAULT_RESOLVE_TYPE
-      end
-    end
-
-    # Print the human-readable name of this type using the query-string naming pattern
-    def to_s
-      name
-    end
-
-    alias :inspect :to_s
-
-    def valid_input?(value)
-      validate_input(value).valid?
-    end
-
-    def validate_input(value)
-      return GraphQL::Query::InputValidationResult.new if value.nil?
-      validate_non_null_input(value)
-    end
-
-    def coerce_input(value)
-      return nil if value.nil?
-      coerce_non_null_input(value)
-    end
-
-    # Types with fields may override this
-    # @param name [String] field name to lookup for this type
-    # @return [GraphQL::Field, nil]
-    def get_field(name)
-      nil
-    end
-
-    # During schema definition, types can be defined inside procs or as strings.
-    # This function converts it to a type instance
-    # @return [GraphQL::BaseType]
-    def self.resolve_related_type(type_arg)
-      case type_arg
-      when Proc
-        # lazy-eval it
-        type_arg.call
-      when String
-        # Get a constant by this name
-        Object.const_get(type_arg)
-      else
-        type_arg
-      end
-    end
-  end
-end

data/lib/graphql/boolean_type.rb

@@ -1,9 +0,0 @@
-GraphQL::BOOLEAN_TYPE = GraphQL::ScalarType.define do
-  # Everything else is nil
-  ALLOWED_INPUTS = [true, false]
-
-  name "Boolean"
-
-  coerce_input -> (value) { ALLOWED_INPUTS.include?(value) ? value : nil }
-  coerce_result -> (value) { !!value }
-end

data/lib/graphql/define/assign_argument.rb

@@ -1,20 +0,0 @@
-module GraphQL
-  module Define
-    # Turn argument configs into a {GraphQL::Argument}.
-    module AssignArgument
-      def self.call(target, name, type = nil, description = nil, default_value: nil, &block)
-        argument = if block_given?
-          GraphQL::Argument.define(&block)
-        else
-          GraphQL::Argument.new
-        end
-        argument.name = name.to_s
-        type && argument.type = type
-        description && argument.description = description
-        !default_value.nil? && argument.default_value = default_value
-
-        target.arguments[name.to_s] = argument
-      end
-    end
-  end
-end

data/lib/graphql/define/assign_enum_value.rb

@@ -1,16 +0,0 @@
-module GraphQL
-  module Define
-    # Turn enum value configs into a {GraphQL::EnumType::EnumValue} and register it with the {GraphQL::EnumType}
-    module AssignEnumValue
-      def self.call(enum_type, name, desc = nil, deprecation_reason: nil, value: name)
-        enum_value = GraphQL::EnumType::EnumValue.new(
-          name: name,
-          description: desc,
-          deprecation_reason: deprecation_reason,
-          value: value
-        )
-        enum_type.add_value(enum_value)
-      end
-    end
-  end
-end

data/lib/graphql/define/assign_object_field.rb

@@ -1,21 +0,0 @@
-module GraphQL
-  module Define
-    # Turn field configs into a {GraphQL::Field} and attach it to a {GraphQL::ObjectType} or {GraphQL::InterfaceType}
-    module AssignObjectField
-      def self.call(fields_type, name, type = nil, desc = nil, field: nil, deprecation_reason: nil, property: nil, complexity: nil, &block)
-        if block_given?
-          field = GraphQL::Field.define(&block)
-        else
-          field ||= GraphQL::Field.new
-        end
-        type && field.type = type
-        desc && field.description = desc
-        property && field.property = property
-        complexity && field.complexity = complexity
-        deprecation_reason && field.deprecation_reason = deprecation_reason
-        field.name ||= name.to_s
-        fields_type.fields[name.to_s] = field
-      end
-    end
-  end
-end

data/lib/graphql/define/assignment_dictionary.rb

@@ -1,26 +0,0 @@
-module GraphQL
-  module Define
-    # Create a hash of definitions out of provided arguments.
-    #
-    # @example Create definitions (some default, some custom)
-    #    hash = AssignmentDictionary.create(:name, :description, field: (value, field_name) -> { value.create_field(field) })
-    #
-    module AssignmentDictionary
-      # Turn `keys` into a hash suitable for {GraphQL::Define::InstanceDefinable}
-      # @param Any number of symbols for default assignment, followed by an (optional) hash of custom assignment procs.
-      # @return [Hash] keys are attributes which may be defined. values are procs which assign values to the target object.
-      def self.create(*keys)
-        initial = if keys.last.is_a?(Hash)
-          keys.pop
-        else
-          {}
-        end
-        keys.inject(initial) do |memo, key|
-          assign_key = "#{key}="
-          memo[key] = -> (target, value) { target.public_send(assign_key, value) }
-          memo
-        end
-      end
-    end
-  end
-end

data/lib/graphql/define/defined_object_proxy.rb

@@ -1,32 +0,0 @@
-module GraphQL
-  module Define
-    class DefinedObjectProxy
-      def initialize(target, dictionary)
-        @target = target
-        @dictionary = dictionary
-      end
-
-      def types
-        GraphQL::Define::TypeDefiner.instance
-      end
-
-      def method_missing(name, *args, &block)
-        definition = @dictionary[name]
-        if definition
-          definition.call(@target, *args, &block)
-        else
-          p "Failed to find config #{name} in #{inspect}"
-          super
-        end
-      end
-
-      def to_s
-        inspect
-      end
-
-      def inspect
-        "<DefinedObjectProxy #{@target} (#{@dictionary.keys})>"
-      end
-    end
-  end
-end

data/lib/graphql/define/instance_definable.rb

@@ -1,79 +0,0 @@
-module GraphQL
-  module Define
-    # This module provides the `.define { ... }` API for {GraphQL::BaseType}, {GraphQL::Field}, {GraphQL::Argument} and {GraphQL::Directive}.
-    #
-    # The goals are:
-    # - Minimal overhead in consuming classes
-    # - Independence between consuming classes
-    # - Extendable by third-party libraries without monkey-patching or other nastiness
-    #
-    # @example Make a class definable
-    #   class Car
-    #     attr_accessor :make, :model, :all_wheel_drive
-    #
-    #     accepts_definitions(
-    #       # These attrs will be defined with plain setters, `{attr}=`
-    #       :make, :model,
-    #       # This attr has a custom definition which applies the config to the target
-    #       doors: -> (car, doors_count) { doors_count.times { car.doors << Door.new } }
-    #     )
-    #   end
-    #
-    #   # Create an instance with `.define`:
-    #   subaru_baja = Car.define do
-    #     make "Subaru"
-    #     model "Baja"
-    #     doors 4
-    #   end
-    #
-    #   # The custom proc was applied:
-    #   subaru_baja.doors #=> [<Door>, <Door>, <Door>, <Door>]
-    #
-    # @example Extending the definition of a class
-    #   # Add some definitions:
-    #   Car.accepts_definitions(:all_wheel_drive)
-    #
-    #   # Use it in a definition
-    #   subaru_baja = Car.define do
-    #     # ...
-    #     all_wheel_drive true
-    #   end
-    #
-    module InstanceDefinable
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        # Define an instance of this class using its {.definitions}.
-        def define(&block)
-          instance = self.new
-          proxy = DefinedObjectProxy.new(instance, dictionary)
-          block && proxy.instance_eval(&block)
-          instance
-        end
-
-        # Attach definitions to this class.
-        # Each symbol in `accepts` will be assigned with `{key}=`.
-        # The last entry in accepts may be a hash of name-proc pairs for custom definitions.
-        def accepts_definitions(*accepts)
-          @own_dictionary = own_dictionary.merge(AssignmentDictionary.create(*accepts))
-        end
-
-        # @return [Hash] combined definitions for self and ancestors
-        def dictionary
-          if superclass.respond_to?(:dictionary)
-            own_dictionary.merge(superclass.dictionary)
-          else
-            own_dictionary
-          end
-        end
-
-        # @return [Hash] definitions for this class only
-        def own_dictionary
-          @own_dictionary ||= {}
-        end
-      end
-    end
-  end
-end

data/lib/graphql/define/non_null_with_bang.rb

@@ -1,15 +0,0 @@
-module GraphQL
-  module Define
-    # Wrap the object in NonNullType in response to `!`
-    # @example required Int type
-    #   !GraphQL::INT_TYPE
-    #
-    module NonNullWithBang
-      # Make the type non-null
-      # @return [GraphQL::NonNullType] a non-null type which wraps the original type
-      def !
-        to_non_null_type
-      end
-    end
-  end
-end