graphql 0.1.0 → 0.2.0

data/lib/graph_ql/fields/abstract_field.rb

@@ -1,37 +0,0 @@
-# Anything can be a Field as long as it responds to:
-#   - #name: String the name to access this field in a query
-#   - #type: Type returned by this field's resolve function
-#   - #description: String
-#   - #resolve(object, arguments, context): Object of Type `type`
-#   - #arguments: ???
-#   - #deprecation_reason
-class GraphQL::AbstractField
-  def name
-    raise NotImplementedError, "#{self.class.name}#name should return the name for accessing this field"
-  end
-
-  def type
-    raise NotImplementedError, "#{self.class.name}#type should return the type class which this field returns"
-  end
-
-  def description
-    raise NotImplementedError, "#{self.class.name}#description should return this field's description"
-  end
-
-
-  def resolve(object, arguments, context)
-    raise NotImplementedError, "#{self.class.name}#resolve(object, arguments, context) should execute this field for object"
-  end
-
-  def arguments
-    {}
-  end
-
-  def deprecated?
-    !!deprecation_reason
-  end
-
-  def deprecation_reason
-    nil
-  end
-end

data/lib/graph_ql/fields/access_field.rb

@@ -1,24 +0,0 @@
-# Implement {AbstractField} by calling the field name on its object
-# and returning the result.
-class GraphQL::AccessField < GraphQL::AbstractField
-  attr_accessor :name, :type
-  attr_reader :description, :arguments, :deprecation_reason
-  def initialize(type:, arguments:, description:, property: nil, deprecation_reason: nil)
-    @type = type
-    @arguments = arguments
-    @description = description
-    @property = property
-    @deprecation_reason = deprecation_reason
-  end
-
-  def resolve(object, args, context)
-    @property.nil? ? GraphQL::Query::DEFAULT_RESOLVE : object.send(@property)
-  end
-
-  def type
-    if @type.is_a?(Proc)
-      @type = @type.call
-    end
-    @type
-  end
-end

data/lib/graph_ql/fields/field.rb

@@ -1,34 +0,0 @@
-class GraphQL::Field < GraphQL::AbstractField
-  extend GraphQL::Definable
-  REQUIRED_DEFINITIONS = [:name, :description, :type]
-  attr_definable(:arguments, :deprecation_reason, *REQUIRED_DEFINITIONS)
-
-  def initialize(&block)
-    @arguments = {}
-    @resolve_proc = -> (o, a, c) { GraphQL::Query::DEFAULT_RESOLVE }
-    yield(self) if block_given?
-  end
-
-  # Used when defining:
-  #   resolve -> (obj, args, ctx) { obj.get_value }
-  # Also used when executing queries:
-  #   field.resolve(obj, args, ctx)
-  def resolve(proc_or_object, arguments=nil, ctx=nil)
-    if arguments.nil? && ctx.nil?
-      @resolve_proc = proc_or_object
-    else
-      @resolve_proc.call(proc_or_object, arguments, ctx)
-    end
-  end
-
-  def type(type_or_proc=nil)
-    if type_or_proc.nil?
-      if @type.is_a?(Proc)
-        @type = @type.call
-      end
-      @type
-    else
-      @type = type_or_proc
-    end
-  end
-end

data/lib/graph_ql/types/abstract_type.rb

@@ -1,14 +0,0 @@
-# Any object can be a type as long as it implements:
-#  - #fields: Hash of { String => Field } pairs
-#  - #kind: one of GraphQL::TypeKinds
-#  - #interfaces: Array of Interfaces
-#  - #name: String
-#  - #description: String
-#
-class GraphQL::AbstractType
-  def fields; raise NotImplementedError; end
-  def kind; raise NotImplementedError; end
-  def interfaces; raise NotImplementedError; end
-  def name; raise NotImplementedError; end
-  def description; raise NotImplementedError; end
-end

data/lib/graph_ql/validations/fields_are_defined_on_type.rb

@@ -1,44 +0,0 @@
-class GraphQL::Validations::FieldsAreDefinedOnType
-  TYPE_INFERRENCE_ROOTS = [GraphQL::Nodes::OperationDefinition, GraphQL::Nodes::FragmentDefinition]
-  FIELD_MODIFIERS = [GraphQL::TypeKinds::LIST]
-
-  def validate(context)
-    visitor = context.visitor
-    TYPE_INFERRENCE_ROOTS.each do |node_class|
-      visitor[node_class] << -> (node){ validate_document_part(node, context) }
-    end
-  end
-
-  private
-  def validate_document_part(part, context)
-    if part.is_a?(GraphQL::Nodes::FragmentDefinition)
-      type = context.schema.types[part.type]
-      validate_selections(type, part.selections, context)
-    elsif part.is_a?(GraphQL::Nodes::OperationDefinition)
-      type = context.schema.public_send(part.operation_type) # mutation root or query root
-      validate_selections(type, part.selections, context)
-    end
-  end
-
-  def validate_selections(type, selections, context)
-    selections
-      .select {|f| f.is_a?(GraphQL::Nodes::Field) } # don't worry about fragments
-      .each do |ast_field|
-        field = type.fields[ast_field.name]
-        if field.nil?
-          context.errors << "Field '#{ast_field.name}' doesn't exist on type '#{type.name}'"
-        else
-          field_type = get_field_type(field)
-          validate_selections(field_type, ast_field.selections, context)
-        end
-      end
-  end
-
-  def get_field_type(field)
-    if FIELD_MODIFIERS.include?(field.type.kind)
-      field.type.of_type
-    else
-      field.type
-    end
-  end
-end

data/lib/graph_ql/validations/fields_will_merge.rb

@@ -1,80 +0,0 @@
-class GraphQL::Validations::FieldsWillMerge
-  HAS_SELECTIONS = [GraphQL::Nodes::OperationDefinition, GraphQL::Nodes::InlineFragment]
-
-  def validate(context)
-    fragments = {}
-    has_selections = []
-    visitor = context.visitor
-    HAS_SELECTIONS.each do |node_class|
-      visitor[node_class] << -> (node) { has_selections << node }
-    end
-    visitor[GraphQL::Nodes::FragmentDefinition] << -> (node) { fragments[node.name] = node }
-    visitor[GraphQL::Nodes::Document].leave << -> (node) {
-      has_selections.each { |node| validate_selections(node.selections, {}, fragments, context.errors)}
-    }
-  end
-
-  private
-
-  def validate_selections(selections, name_to_field, fragments, errors)
-    selections.each do |field|
-      if field.is_a?(GraphQL::Nodes::InlineFragment)
-        validate_selections(field.selections, name_to_field, fragments, errors)
-      elsif field.is_a?(GraphQL::Nodes::FragmentSpread)
-        fragment = fragments[field.name]
-        validate_selections(fragment.selections, name_to_field, fragments, errors)
-      else
-        field_errors = validate_field(field, name_to_field)
-        errors.push(*field_errors)
-        validate_selections(field.selections, name_to_field, fragments, errors)
-      end
-    end
-  end
-
-  def validate_field(field, name_to_field)
-    name_in_selection = field.alias || field.name
-    name_to_field[name_in_selection] ||= field
-    first_field_def = name_to_field[name_in_selection]
-    comparison = FieldDefinitionComparison.new(name_in_selection, first_field_def, field)
-    comparison.errors
-  end
-
-  # Compare two field definitions, add errors to the list if there are any
-  class FieldDefinitionComparison
-    NAMED_VALUES = [GraphQL::Nodes::Enum, GraphQL::Nodes::VariableIdentifier]
-    attr_reader :errors
-    def initialize(name, prev_def, next_def)
-      errors = []
-      if prev_def.name != next_def.name
-        errors << "Field '#{name}' has a field conflict: #{prev_def.name} or #{next_def.name}?"
-      end
-      prev_arguments = reduce_list(prev_def.arguments)
-      next_arguments = reduce_list(next_def.arguments)
-      if prev_arguments != next_arguments
-        errors << "Field '#{name}' has an argument conflict: #{JSON.dump(prev_arguments)} or #{JSON.dump(next_arguments)}?"
-      end
-      prev_directive_names = prev_def.directives.map(&:name)
-      next_directive_names = next_def.directives.map(&:name)
-      if prev_directive_names != next_directive_names
-        errors << "Field '#{name}' has a directive conflict: [#{prev_directive_names.join(", ")}] or [#{next_directive_names.join(", ")}]?"
-      end
-      prev_directive_args = prev_def.directives.map {|d| reduce_list(d.arguments) }
-      next_directive_args = next_def.directives.map {|d| reduce_list(d.arguments) }
-      if prev_directive_args != next_directive_args
-        errors << "Field '#{name}' has a directive argument conflict: #{JSON.dump(prev_directive_args)} or #{JSON.dump(next_directive_args)}?"
-      end
-      @errors = errors
-    end
-
-    private
-
-    # Turn AST tree into a hash
-    # can't look up args, the names just have to match
-    def reduce_list(args)
-      args.reduce({}) do |memo, a|
-        memo[a.name] = NAMED_VALUES.include?(a.value.class) ? a.value.name : a.value
-        memo
-      end
-    end
-  end
-end

data/lib/graph_ql/validations/fragments_are_used.rb

@@ -1,24 +0,0 @@
-class GraphQL::Validations::FragmentsAreUsed
-  def validate(context)
-    v = context.visitor
-    used_fragment_names = []
-    defined_fragment_names = []
-    v[GraphQL::Nodes::FragmentSpread] << -> (node) { used_fragment_names <<  node.name }
-    v[GraphQL::Nodes::FragmentDefinition] << -> (node) { defined_fragment_names << node.name}
-    v[GraphQL::Nodes::Document].leave << -> (node) { add_errors(context.errors, used_fragment_names, defined_fragment_names) }
-  end
-
-  private
-
-  def add_errors(errors, used_fragment_names, defined_fragment_names)
-    undefined_fragment_names = used_fragment_names - defined_fragment_names
-    if undefined_fragment_names.any?
-      errors << "Some fragments were used but not defined: #{undefined_fragment_names.join(", ")}"
-    end
-
-    unused_fragment_names = defined_fragment_names - used_fragment_names
-    if unused_fragment_names.any?
-      errors << "Some fragments were defined but not used: #{unused_fragment_names.join(", ")}"
-    end
-  end
-end

data/lib/graph_ql/validator.rb

@@ -1,29 +0,0 @@
-class GraphQL::Validator
-  VALIDATORS = [
-    GraphQL::Validations::FragmentsAreUsed,
-  ]
-
-  def initialize(schema:, validators: VALIDATORS)
-    @schema = schema
-    @validators = validators
-  end
-
-  def validate(document)
-    context = Context.new(@schema, document)
-    @validators.each do |validator|
-      validator.new.validate(context)
-    end
-    context.visitor.visit(document)
-    context.errors
-  end
-
-  class Context
-    attr_reader :schema, :document, :errors, :visitor
-    def initialize(schema, document)
-      @schema = schema
-      @document = document
-      @visitor = GraphQL::Visitor.new
-      @errors = []
-    end
-  end
-end

data/spec/graph_ql/validations/fields_are_defined_on_type_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe GraphQL::Validations::FieldsAreDefinedOnType do
-  let(:document) { GraphQL.parse("
-    query getCheese($sourceVar: DairyAnimal!) {
-      notDefinedField { name }
-      cheese(id: 1) { nonsenseField, flavor }
-      fromSource(source: COW) { bogusField }
-    }
-
-    fragment cheeseFields on Cheese { fatContent, hogwashField }
-  ")}
-
-  let(:validator) { GraphQL::Validator.new(schema: DummySchema, validators: [GraphQL::Validations::FieldsAreDefinedOnType]) }
-  let(:errors) { validator.validate(document) }
-  it "finds fields that are requested on types that don't have that field" do
-    expected_errors = [
-      "Field 'notDefinedField' doesn't exist on type 'Query'",  # from query root
-      "Field 'nonsenseField' doesn't exist on type 'Cheese'",   # from another field
-      "Field 'bogusField' doesn't exist on type 'Cheese'",      # from a list
-      "Field 'hogwashField' doesn't exist on type 'Cheese'",    # from a fragment
-    ]
-    assert_equal(expected_errors, errors)
-  end
-
-  it 'finds invalid fields on interfaces'
-  it 'finds invalid fields on unions'
-end

data/spec/graph_ql/validations/fragments_are_used_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe GraphQL::Validations::FragmentsAreUsed do
-  let(:document) { GraphQL.parse("
-    query getCheese {
-      name,
-      ...cheeseFields,
-      origin {
-        ...originFields
-        ...undefinedFields
-      }
-    }
-    fragment cheeseFields on Cheese { fatContent }
-    fragment originFields on Country { name, continent { ...continentFields }}
-    fragment continentFields on Continent { name }
-    fragment unusedFields on Cheese { is, not, used }
-  ")}
-
-  let(:validator) { GraphQL::Validator.new(schema: nil, validators: [GraphQL::Validations::FragmentsAreUsed]) }
-  let(:errors) { validator.validate(document) }
-
-  it 'adds errors for unused fragment definitions' do
-    assert_includes(errors, 'Some fragments were defined but not used: unusedFields')
-  end
-  it 'adds errors for undefined fragment spreads' do
-    assert_includes(errors, 'Some fragments were used but not defined: undefinedFields')
-  end
-end

data/spec/graph_ql/validator_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-class SchemaErrorValidator
-  def validate(context)
-    context.errors << "Something is wrong: #{context.schema}"
-  end
-end
-
-class DocumentErrorValidator
-  def validate(context)
-    context.errors << "Something is wrong: #{context.document.name}"
-  end
-end
-
-describe GraphQL::Validator do
-  let(:document)  { OpenStruct.new(name: "This is not a document", children: []) }
-  let(:validator) { GraphQL::Validator.new(schema: "This is not a schema", validators: [SchemaErrorValidator, DocumentErrorValidator]) }
-
-  it 'uses validators' do
-    errors = validator.validate(document)
-    expected_errors = ["Something is wrong: This is not a schema", "Something is wrong: This is not a document"]
-    assert_equal(expected_errors, errors)
-  end
-end