graphql 0.16.0 → 2.0.15

data/lib/graphql/internal_representation/rewrite.rb

@@ -1,177 +0,0 @@
-module GraphQL
-  module InternalRepresentation
-    # Convert an AST into a tree of {InternalRepresentation::Node}s
-    #
-    # This rides along with {StaticValidation}, building a tree of nodes.
-    #
-    # However, if any errors occurred during validation, the resulting tree is bogus.
-    #  (For example, `nil` could have been pushed instead of a type.)
-    class Rewrite
-      include GraphQL::Language
-
-      # @return [Hash<String => InternalRepresentation::Node>] internal representation of each query root (operation, fragment)
-      attr_reader :operations
-
-      def initialize
-        # { String => Node } Tracks the roots of the query
-        @operations = {}
-        @fragments = {}
-        # [String...] fragments which don't have fragments inside them
-        @independent_fragments = []
-        # Tracks the current node during traversal
-        # Stack<InternalRepresentation::Node>
-        @nodes = []
-        # This tracks dependencies from fragment to Node where it was used
-        # { frag_name => [dependent_node, dependent_node]}
-        @fragment_spreads = Hash.new { |h, k| h[k] = []}
-        # [Nodes::Directive ... ] directive affecting the current scope
-        @parent_directives = []
-      end
-
-      def validate(context)
-        visitor = context.visitor
-
-        visitor[Nodes::OperationDefinition].enter << -> (ast_node, prev_ast_node) {
-          node = Node.new(
-            return_type: context.type_definition.unwrap,
-            ast_node: ast_node,
-          )
-          @nodes.push(node)
-          @operations[ast_node.name] = node
-        }
-
-        visitor[Nodes::Field].enter << -> (ast_node, prev_ast_node) {
-          parent_node = @nodes.last
-          node_name = ast_node.alias || ast_node.name
-          # This node might not be novel, eg inside an inline fragment
-          # but it could contain new type information, which is captured below.
-          # (StaticValidation ensures that merging fields is fair game)
-          node = parent_node.children[node_name] ||= begin
-            Node.new(
-              return_type: context.type_definition && context.type_definition.unwrap,
-              ast_node: ast_node,
-              name: node_name,
-              definition: context.field_definition,
-            )
-          end
-          node.on_types.add(context.parent_type_definition.unwrap)
-          @nodes.push(node)
-          @parent_directives.push([])
-        }
-
-        visitor[Nodes::InlineFragment].enter << -> (ast_node, prev_ast_node) {
-          @parent_directives.push([])
-        }
-
-        visitor[Nodes::Directive].enter << -> (ast_node, prev_ast_node) {
-          # It could be a query error where a directive is somewhere it shouldn't be
-          if @parent_directives.any?
-            @parent_directives.last << Node.new(
-              name: ast_node.name,
-              ast_node: ast_node,
-              definition: context.directive_definition,
-            )
-          end
-        }
-
-        visitor[Nodes::FragmentSpread].enter << -> (ast_node, prev_ast_node) {
-          # Record _both sides_ of the dependency
-          spread_node = Node.new(
-            name: ast_node.name,
-            ast_node: ast_node,
-          )
-          parent_node = @nodes.last
-          # The parent node has a reference to the fragment
-          parent_node.spreads.push(spread_node)
-          # And keep a reference from the fragment to the parent node
-          @fragment_spreads[ast_node.name].push(parent_node)
-          @nodes.push(spread_node)
-          @parent_directives.push([])
-        }
-
-        visitor[Nodes::FragmentDefinition].enter << -> (ast_node, prev_ast_node) {
-          node = Node.new(
-            name: ast_node.name,
-            return_type: context.type_definition,
-            ast_node: ast_node,
-          )
-          @nodes.push(node)
-          @fragments[ast_node.name] = node
-        }
-
-        visitor[Nodes::InlineFragment].leave  << -> (ast_node, prev_ast_node) {
-          @parent_directives.pop
-        }
-
-        visitor[Nodes::FragmentSpread].leave  << -> (ast_node, prev_ast_node) {
-          # Capture any directives that apply to this spread
-          # so that they can be applied to fields when
-          # the fragment is merged in later
-          spread_node = @nodes.pop
-          spread_node.directives.merge(@parent_directives.flatten)
-          @parent_directives.pop
-        }
-
-        visitor[Nodes::FragmentDefinition].leave << -> (ast_node, prev_ast_node) {
-          # This fragment doesn't depend on any others,
-          # we should save it as the starting point for dependency resolution
-          frag_node = @nodes.pop
-          if frag_node.spreads.none?
-            @independent_fragments << frag_node
-          end
-        }
-
-        visitor[Nodes::OperationDefinition].leave << -> (ast_node, prev_ast_node) {
-          @nodes.pop
-        }
-
-        visitor[Nodes::Field].leave << -> (ast_node, prev_ast_node) {
-          # Pop this field's node
-          # and record any directives that were visited
-          # during this field & before it (eg, inline fragments)
-          field_node = @nodes.pop
-          field_node.directives.merge(@parent_directives.flatten)
-          @parent_directives.pop
-        }
-
-        visitor[Nodes::Document].leave << -> (ast_node, prev_ast_node) {
-          # Resolve fragment dependencies. Start with fragments with no
-          # dependencies and work along the spreads.
-          while fragment_node = @independent_fragments.pop
-            fragment_usages = @fragment_spreads[fragment_node.name]
-            while dependent_node = fragment_usages.pop
-              # remove self from dependent_node.spreads
-              rejected_spread_nodes = dependent_node.spreads.select { |spr| spr.name == fragment_node.name }
-              rejected_spread_nodes.each { |r_node| dependent_node.spreads.delete(r_node) }
-
-              # resolve the dependency (merge into dependent node)
-              deep_merge(dependent_node, fragment_node, rejected_spread_nodes.first.directives)
-
-              if dependent_node.spreads.none? && dependent_node.ast_node.is_a?(Nodes::FragmentDefinition)
-                @independent_fragments.push(dependent_node)
-              end
-            end
-          end
-        }
-      end
-
-      private
-
-      # Merge the chilren from `fragment_node` into `parent_node`. Merge `directives` into each of those fields.
-      def deep_merge(parent_node, fragment_node, directives)
-        fragment_node.children.each do |name, child_node|
-          deep_merge_child(parent_node, name, child_node, directives)
-        end
-      end
-
-      # Merge `node` into `parent_node`'s children, as `name`, applying `extra_directives`
-      def deep_merge_child(parent_node, name, node, extra_directives)
-        child_node = parent_node.children[name] ||= node.dup
-        node.children.each do |merge_child_name, merge_child_node|
-          deep_merge_child(child_node, merge_child_name, merge_child_node, [])
-        end
-        child_node.directives.merge(extra_directives)
-      end
-    end
-  end
-end

data/lib/graphql/internal_representation.rb

@@ -1,2 +0,0 @@
-require "graphql/internal_representation/node"
-require "graphql/internal_representation/rewrite"

data/lib/graphql/introspection/arguments_field.rb

@@ -1,5 +0,0 @@
-GraphQL::Introspection::ArgumentsField = GraphQL::Field.define do
-  description "Arguments allowed to this object"
-  type !GraphQL::ListType.new(of_type: !GraphQL::Introspection::InputValueType)
-  resolve -> (target, a, c) { target.arguments.values }
-end

data/lib/graphql/introspection/enum_values_field.rb

@@ -1,13 +0,0 @@
-GraphQL::Introspection::EnumValuesField = GraphQL::Field.define do
-  description "Values for this enum"
-  type types[!GraphQL::Introspection::EnumValueType]
-  argument :includeDeprecated, types.Boolean, default_value: false
-  resolve -> (object, arguments, context) do
-    return nil if !object.kind.enum?
-    fields = object.values.values
-    if !arguments["includeDeprecated"]
-      fields = fields.select {|f| !f.deprecation_reason }
-    end
-    fields
-  end
-end

data/lib/graphql/introspection/fields_field.rb

@@ -1,13 +0,0 @@
-GraphQL::Introspection::FieldsField = GraphQL::Field.define do
-  description "List of fields on this object"
-  type -> { types[!GraphQL::Introspection::FieldType] }
-  argument :includeDeprecated, GraphQL::BOOLEAN_TYPE, default_value: false
-  resolve -> (object, arguments, context) {
-    return nil if !object.kind.fields?
-    fields = object.all_fields
-    if !arguments["includeDeprecated"]
-      fields = fields.select {|f| !f.deprecation_reason }
-    end
-    fields.sort_by(&:name)
-  }
-end

data/lib/graphql/introspection/input_fields_field.rb

@@ -1,12 +0,0 @@
-GraphQL::Introspection::InputFieldsField = GraphQL::Field.define do
-  name "inputFields"
-  description "fields on this input object"
-  type types[!GraphQL::Introspection::InputValueType]
-  resolve -> (target, a, c) {
-    if target.kind.input_object?
-      target.input_fields.values
-    else
-      nil
-    end
-  }
-end

data/lib/graphql/introspection/interfaces_field.rb

@@ -1,5 +0,0 @@
-GraphQL::Introspection::InterfacesField = GraphQL::Field.define do
-  description "Interfaces which this object implements"
-  type -> { types[!GraphQL::Introspection::TypeType] }
-  resolve -> (target, a, c) { target.kind.object? ? target.interfaces : nil }
-end

data/lib/graphql/introspection/of_type_field.rb

@@ -1,6 +0,0 @@
-GraphQL::Introspection::OfTypeField = GraphQL::Field.define do
-  name "ofType"
-  description "The modified type of this type"
-  type -> { GraphQL::Introspection::TypeType }
-  resolve -> (obj, args, ctx) { obj.kind.wraps? ? obj.of_type : nil }
-end

data/lib/graphql/introspection/possible_types_field.rb

@@ -1,11 +0,0 @@
-GraphQL::Introspection::PossibleTypesField = GraphQL::Field.define do
-  description "Types which compose this Union or Interface"
-  type -> { types[!GraphQL::Introspection::TypeType] }
-  resolve -> (target, args, ctx) {
-    if target.kind.resolves?
-      ctx.schema.possible_types(target)
-    else
-      nil
-    end
-  }
-end

data/lib/graphql/introspection/schema_field.rb

@@ -1,15 +0,0 @@
-module GraphQL
-  module Introspection
-    # A wrapper to implement `__schema`
-    class SchemaField
-      def self.create(wrapped_type)
-        GraphQL::Field.define do
-          name("__schema")
-          description("This GraphQL schema")
-          type(!GraphQL::Introspection::SchemaType)
-          resolve -> (o, a, c) { wrapped_type }
-        end
-      end
-    end
-  end
-end

data/lib/graphql/introspection/type_by_name_field.rb

@@ -1,16 +0,0 @@
-module GraphQL
-  module Introspection
-    # A wrapper to create `__type(name: )` dynamically.
-    class TypeByNameField
-      def self.create(type_hash)
-        GraphQL::Field.define do
-          name("__type")
-          description("A type in the GraphQL system")
-          type(!GraphQL::Introspection::TypeType)
-          argument :name, !types.String
-          resolve -> (o, args, c) { type_hash[args["name"]] }
-        end
-      end
-    end
-  end
-end

data/lib/graphql/introspection/typename_field.rb

@@ -1,15 +0,0 @@
-module GraphQL
-  module Introspection
-    # A wrapper to create `__typename`.
-    class TypenameField
-      def self.create(wrapped_type)
-        GraphQL::Field.define do
-          name "__typename"
-          description "The name of this type"
-          type -> { !GraphQL::STRING_TYPE }
-          resolve -> (obj, a, c) { wrapped_type.name }
-        end
-      end
-    end
-  end
-end

data/lib/graphql/list_type.rb

@@ -1,46 +0,0 @@
-module GraphQL
-  # A list type wraps another type.
-  #
-  # Get the underlying type with {#unwrap}
-  class ListType < GraphQL::BaseType
-    include GraphQL::BaseType::ModifiesAnotherType
-    attr_reader :of_type, :name
-    def initialize(of_type:)
-      @name = "List"
-      @of_type = of_type
-    end
-
-    def kind
-      GraphQL::TypeKinds::LIST
-    end
-
-    def to_s
-      "[#{of_type.to_s}]"
-    end
-
-    def validate_non_null_input(value)
-      result = GraphQL::Query::InputValidationResult.new
-
-      ensure_array(value).each_with_index do |item, index|
-        item_result = of_type.validate_input(item)
-        if !item_result.valid?
-          result.merge_result!(index, item_result)
-        end
-      end
-
-      result
-    end
-
-
-    def coerce_non_null_input(value)
-      ensure_array(value).map{ |item| of_type.coerce_input(item) }
-    end
-
-
-    private
-
-    def ensure_array(value)
-      value.is_a?(Array) ? value : [value]
-    end
-  end
-end

data/lib/graphql/non_null_type.rb

@@ -1,43 +0,0 @@
-module GraphQL
-  # A non-null type wraps another type.
-  #
-  # Get the underlying type with {#unwrap}
-  class NonNullType < GraphQL::BaseType
-    include GraphQL::BaseType::ModifiesAnotherType
-
-    attr_reader :of_type
-    def initialize(of_type:)
-      @of_type = of_type
-    end
-
-    def name
-      "Non-Null"
-    end
-
-    def valid_input?(value)
-      validate_input(value).valid?
-    end
-
-    def validate_input(value)
-      if value.nil?
-        result = GraphQL::Query::InputValidationResult.new
-        result.add_problem("Expected value to not be null")
-        result
-      else
-        of_type.validate_input(value)
-      end
-    end
-
-    def coerce_input(value)
-      of_type.coerce_input(value)
-    end
-
-    def kind
-      GraphQL::TypeKinds::NON_NULL
-    end
-
-    def to_s
-      "#{of_type.to_s}!"
-    end
-  end
-end

data/lib/graphql/object_type.rb

@@ -1,93 +0,0 @@
-module GraphQL
-  # This type exposes fields on an object.
-  #
-  # @example defining a type for your IMDB clone
-  #   MovieType = GraphQL::ObjectType.define do
-  #     name "Movie"
-  #     description "A full-length film or a short film"
-  #     interfaces [ProductionInterface, DurationInterface]
-  #
-  #     field :runtimeMinutes, !types.Int, property: :runtime_minutes
-  #     field :director, PersonType
-  #     field :cast, CastType
-  #     field :starring, types[PersonType] do
-  #       arguments :limit, types.Int
-  #       resolve -> (object, args, ctx) {
-  #         stars = object.cast.stars
-  #         args[:limit] && stars = stars.limit(args[:limit])
-  #         stars
-  #       }
-  #      end
-  #   end
-  #
-  class ObjectType < GraphQL::BaseType
-    accepts_definitions :interfaces, field: GraphQL::Define::AssignObjectField
-    attr_accessor :name, :description
-
-    # @return [Hash<String => GraphQL::Field>] Map String fieldnames to their {GraphQL::Field} implementations
-    attr_accessor :fields
-
-    def initialize
-      @fields = {}
-      @dirty_interfaces = []
-    end
-
-    # @param new_interfaces [Array<GraphQL::Interface>] interfaces that this type implements
-    def interfaces=(new_interfaces)
-      @clean_interfaces = nil
-      @dirty_interfaces = new_interfaces
-    end
-
-    def interfaces
-      @clean_interfaces ||= begin
-        @dirty_interfaces.map { |i_type| GraphQL::BaseType.resolve_related_type(i_type) }
-      rescue
-        @dirty_interfaces
-      end
-    end
-
-    def kind
-      GraphQL::TypeKinds::OBJECT
-    end
-
-    # @return [GraphQL::Field] The field definition for `field_name` (may be inherited from interfaces)
-    def get_field(field_name)
-      fields[field_name] || interface_fields[field_name]
-    end
-
-    # @return [Array<GraphQL::Field>] All fields, including ones inherited from interfaces
-    def all_fields
-      interface_fields.merge(self.fields).values
-    end
-
-    private
-
-    # Create a {name => defn} hash for fields inherited from interfaces
-    def interface_fields
-      interfaces.reduce({}) do |memo, iface|
-        memo.merge!(iface.fields)
-      end
-    end
-
-
-    # Error raised when the value provided for a field can't be resolved to one of the possible types
-    # for the field.
-    class UnresolvedTypeError < GraphQL::Error
-      attr_reader :field_name, :field_type, :parent_type
-
-      def initialize(field_name, field_type, parent_type)
-        @field_name = field_name
-        @field_type = field_type
-        @parent_type = parent_type
-        super(exception_message)
-      end
-
-      private
-
-      def exception_message
-        "The value returned for field #{field_name} on #{parent_type} could not be resolved "\
-        "to one of the possible types for #{field_type}."
-      end
-    end
-  end
-end

data/lib/graphql/query/arguments.rb

@@ -1,76 +0,0 @@
-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
-
-      def initialize(values)
-        @original_values = values
-        @argument_values = values.inject({}) do |memo, (inner_key, inner_value)|
-          memo[inner_key.to_s] = wrap_value(inner_value)
-          memo
-        end
-      end
-
-      # @param [String, Symbol] name or index of value to access
-      # @return [Object] the argument at that key
-      def [](key)
-        @argument_values[key.to_s]
-      end
-
-      # Get the original Ruby hash
-      # @return [Hash] the original values hash
-      def to_h
-        @unwrapped_values ||= unwrap_value(@original_values)
-      end
-
-      def_delegators :string_key_values, :keys, :values, :each
-
-      private
-
-      def wrap_value(value)
-        case value
-        when Array
-          value.map { |item| wrap_value(item) }
-        when Hash
-          self.class.new(value)
-        else
-          value
-        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
-          value.to_h
-        else
-          value
-        end
-      end
-
-      def string_key_values
-        @string_key_values ||= stringify_keys(to_h)
-      end
-
-      def stringify_keys(value)
-        case value
-        when Hash
-          value.inject({}) { |memo, (k, v)| memo[k.to_s] = stringify_keys(v); memo }
-        when Array
-          value.map { |v| stringify_keys(v) }
-        else
-          value
-        end
-      end
-    end
-  end
-end

data/lib/graphql/query/directive_resolution.rb

@@ -1,16 +0,0 @@
-module GraphQL
-  class Query
-    module DirectiveResolution
-      def self.include_node?(irep_node, query)
-        irep_node.directives.each do |directive_node|
-          directive_defn = directive_node.definition
-          args = query.arguments_for(directive_node)
-          if !directive_defn.include?(args)
-            return false
-          end
-        end
-        true
-      end
-    end
-  end
-end

data/lib/graphql/query/executor.rb

@@ -1,45 +0,0 @@
-module GraphQL
-  class Query
-    class Executor
-      # @return [GraphQL::Query] the query being executed
-      attr_reader :query
-
-      def initialize(query)
-        @query = query
-      end
-
-      # Evalute {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.schema.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 = execution_strategy.execute(operation, root_type, query)
-        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