graphql 0.0.4 → 0.1.0

data/lib/graph_ql/validations/fields_are_defined_on_type.rb

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,29 @@
+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/lib/graph_ql/version.rb

@@ -0,0 +1,3 @@
+module GraphQL
+  VERSION = "0.1.0"
+end

data/lib/graphql.rb

@@ -1,121 +1,114 @@
 require "active_support/core_ext/object/blank"
 require "active_support/core_ext/string/inflections"
+require "active_support/dependencies/autoload"
 require "json"
 require "parslet"
 
 module GraphQL
-  autoload(:Call,                     "graphql/call")
-  autoload(:Connection,               "graphql/connection")
-  autoload(:FieldDefiner,             "graphql/field_definer")
-  autoload(:Field,                    "graphql/field")
-  autoload(:Node,                     "graphql/node")
-  autoload(:Query,                    "graphql/query")
-  autoload(:RootCall,                 "graphql/root_call")
-  autoload(:RootCallArgument,         "graphql/root_call_argument")
-  autoload(:RootCallArgumentDefiner,  "graphql/root_call_argument_definer")
-  autoload(:VERSION,                  "graphql/version")
+  extend ActiveSupport::Autoload
+  autoload(:Directive)
+  autoload(:Enum)
+  autoload(:Interface)
+  autoload(:Parser)
+  autoload(:Query)
+  autoload(:Repl)
+  autoload(:Schema)
+  autoload(:TypeKinds)
+  autoload(:Union)
+  autoload(:Validator)
+  autoload(:VERSION)
 
-  # These objects are used for introspections (eg, responding to `schema()` calls).
-  module Introspection
-    autoload(:CallType,             "graphql/introspection/call_type")
-    autoload(:Connection,           "graphql/introspection/connection")
-    autoload(:FieldType,            "graphql/introspection/field_type")
-    autoload(:RootCallArgumentNode, "graphql/introspection/root_call_argument_node")
-    autoload(:RootCallType,         "graphql/introspection/root_call_type")
-    autoload(:SchemaCall,           "graphql/introspection/schema_call")
-    autoload(:SchemaType,           "graphql/introspection/schema_type")
-    autoload(:TypeCall,             "graphql/introspection/type_call")
-    autoload(:TypeType,             "graphql/introspection/type_type")
+  autoload_under "directives" do
+    autoload(:DirectiveChain)
+    autoload(:IncludeDirective)
+    autoload(:SkipDirective)
   end
 
-  # These objects are singletons used to parse queries
-  module Parser
-    autoload(:Parser,     "graphql/parser/parser")
-    autoload(:Transform,  "graphql/parser/transform")
+  autoload_under "fields" do
+    autoload(:AbstractField)
+    autoload(:AccessField)
+    autoload(:Field)
   end
 
-  # These objects are used to track the schema of the graph
-  module Schema
-    autoload(:ALL,              "graphql/schema/all")
-    autoload(:Schema,           "graphql/schema/schema")
-    autoload(:SchemaValidation, "graphql/schema/schema_validation")
+  autoload_under "introspection" do
+    autoload(:ArgumentsField)
+    autoload(:DirectiveType)
+    autoload(:EnumValuesField)
+    autoload(:EnumValueType)
+    autoload(:FieldType)
+    autoload(:FieldsField)
+    autoload(:InputValueType)
+    autoload(:InputFieldsField)
+    autoload(:OfTypeField)
+    autoload(:PossibleTypesField)
+    autoload(:SchemaType)
+    autoload(:TypeKindEnum)
+    autoload(:TypeType)
   end
 
-  # These objects are skinny wrappers for going from the AST to actual {Node} and {Field} instances.
-  module Syntax
-    autoload(:Call,     "graphql/syntax/call")
-    autoload(:Field,    "graphql/syntax/field")
-    autoload(:Query,    "graphql/syntax/query")
-    autoload(:Fragment, "graphql/syntax/fragment")
-    autoload(:Node,     "graphql/syntax/node")
-    autoload(:Variable, "graphql/syntax/variable")
+  autoload_under "parser" do
+    autoload(:Nodes)
+    autoload(:Parser)
+    autoload(:Transform)
+    autoload(:Visitor)
   end
 
-  # These objects expose values
-  module Types
-    autoload(:BooleanType, "graphql/types/boolean_type")
-    autoload(:ObjectType, "graphql/types/object_type")
-    autoload(:StringType, "graphql/types/string_type")
-    autoload(:NumberType, "graphql/types/number_type")
+  autoload_under "types" do
+    autoload(:AbstractType)
+    autoload(:BOOLEAN_TYPE)
+    autoload(:ScalarType)
+    autoload(:FLOAT_TYPE)
+    autoload(:InputObjectType)
+    autoload(:InputValue)
+    autoload(:INT_TYPE)
+    autoload(:ListType)
+    autoload(:NonNullType)
+    autoload(:NonNullWithBang)
+    autoload(:ObjectType)
+    autoload(:STRING_TYPE)
+    autoload(:TypeDefiner)
   end
-  # @abstract
-  # Base class for all errors, so you can rescue from all graphql errors at once.
-  class Error < RuntimeError; end
-  # This node doesn't have a field with that name.
-  class FieldNotDefinedError < Error
-    def initialize(node_class, field_name)
-      class_name = node_class.name
-      defined_field_names = node_class.all_fields.keys
-      super("#{class_name}##{field_name} was requested, but it isn't defined. Defined fields are: #{defined_field_names}")
-    end
-  end
-  # The class that this node is supposed to expose isn't defined
-  class ExposesClassMissingError < Error
-    def initialize(node_class)
-      super("#{node_class.name} exposes #{node_class.exposes_class_names.join(", ")}, but that class wasn't found.")
-    end
-  end
-  # There's no Node defined for that kind of object.
-  class NodeNotDefinedError < Error
-    def initialize(node_name)
-      super("#{node_name} was requested but was not found. Defined nodes are: #{SCHEMA.type_names}")
-    end
-  end
-  # This node doesn't have a connection with that name.
-  class  ConnectionNotDefinedError < Error
-    def initialize(node_name)
-      super("#{node_name} was requested but was not found. Defined connections are: #{SCHEMA.connection_names}")
-    end
-  end
-  # The root call of this query isn't in the schema.
-  class RootCallNotDefinedError < Error
-    def initialize(name)
-      super("Call '#{name}' was requested but was not found. Defined calls are: #{SCHEMA.call_names}")
-    end
+
+  module Validations
+    extend ActiveSupport::Autoload
+    autoload(:FieldsWillMerge)
+    autoload(:FragmentsAreUsed)
+    autoload(:FieldsAreDefinedOnType)
   end
-  # The query couldn't be parsed.
-  class SyntaxError < Error
-    def initialize(line, col, string)
-      lines = string.split("\n")
-      super("Syntax Error at (#{line}, #{col}), check usage: #{string}")
-    end
+
+  PARSER = Parser.new
+  TRANSFORM = Transform.new
+
+  def self.parse(string, as: nil)
+    parser = as ? GraphQL::PARSER.send(as) : GraphQL::PARSER
+    tree = parser.parse(string)
+    GraphQL::TRANSFORM.apply(tree)
+  rescue Parslet::ParseFailed => error
+    line, col = error.cause.source.line_and_column
+    raise [line, col, string].join(", ")
   end
-  # This root call takes different arguments.
-  class RootCallArgumentError < Error
-    def initialize(declaration, actual)
-      super("Wrong type for #{declaration.name}: expected a #{declaration.type} but got #{actual}")
+
+
+  module Definable
+    def attr_definable(*names)
+      attr_accessor(*names)
+      names.each do |name|
+        ivar_name = "@#{name}".to_sym
+        define_method(name) do |new_value=nil|
+          new_value && self.instance_variable_set(ivar_name, new_value)
+          instance_variable_get(ivar_name)
+        end
+      end
     end
   end
 
-  # Singleton {Parser::Parser} instance
-  PARSER = Parser::Parser.new
-  # This singleton contains all defined nodes and fields.
-  SCHEMA = Schema::Schema.instance
-  # Singleton {Parser::Transform} instance
-  TRANSFORM = Parser::Transform.new
-  # preload these so they're in SCHEMA
-  ["introspection", "types"].each do |preload_dir|
-    Dir["#{File.dirname(__FILE__)}/graphql/#{preload_dir}/*.rb"].each { |f| require f }
+  module Forwardable
+    def delegate(*methods, to:)
+      methods.each do |method_name|
+        define_method(method_name) do |*args|
+          self.public_send(to).public_send(method_name, *args)
+        end
+      end
+    end
   end
-  Node.field.__type__(:__type__)
-end
+end

data/readme.md

@@ -2,190 +2,30 @@
 
 [![Build Status](https://travis-ci.org/rmosolgo/graphql-ruby.svg?branch=master)](https://travis-ci.org/rmosolgo/graphql-ruby)
 [![Gem Version](https://badge.fury.io/rb/graphql.svg)](https://rubygems.org/gems/graphql)
-[![Dependency Status](https://gemnasium.com/rmosolgo/graphql-ruby.svg)](https://gemnasium.com/rmosolgo/graphql-ruby)
 [![Code Climate](https://codeclimate.com/github/rmosolgo/graphql-ruby/badges/gpa.svg)](https://codeclimate.com/github/rmosolgo/graphql-ruby)
 [![Test Coverage](https://codeclimate.com/github/rmosolgo/graphql-ruby/badges/coverage.svg)](https://codeclimate.com/github/rmosolgo/graphql-ruby)
 [![built with love](https://cloud.githubusercontent.com/assets/2231765/6766607/d07992c6-cfc9-11e4-813f-d9240714dd50.png)](http://rmosolgo.github.io/react-badges/)
 
+__Current status__: rewriting according to spec, see also the previous [prototype implementation](https://github.com/rmosolgo/graphql-ruby/tree/74ad3c30a6d8db010ec3856f5871f8a02fcfba42)!
 
-Create a GraphQL interface by implementing [__nodes__](#nodes) and [__calls__](#calls), then running [__queries__](#queries).
+## Overview
 
-API Docs: <http://rubydoc.info/gems/graphql>
+- See the __[test schema](https://github.com/rmosolgo/graphql-ruby/blob/master/spec/support/dummy_app.rb)__ for an example GraphQL schema in Ruby.
+- See __[query_spec.rb](https://github.com/rmosolgo/graphql-ruby/blob/master/spec/graph_ql/query_spec.rb)__ for an example of query execution.
 
-## To do:
+## To Do:
 
-- How do you express failure? HTTP response? `errors` key?
-- Handle blank objects in nested calls (how? wait for spec)
-- Implement calls as arguments
-- double-check how to handle `pals.first(3) { count }`
-- Implement call argument introspection (wait for spec)
+- Validations:
+  - implement lots of validators
+  - build error object with position
+  - Express failure with `errors` key (http://facebook.github.io/graphql/#sec-Errors)
+- directives:
+  - `@skip` has precedence over `@include`
+  - directives on fragments: http://facebook.github.io/graphql/#sec-Fragment-Directives
+- field merging (https://github.com/graphql/graphql-js/issues/19#issuecomment-118515077)
 
-## Example Implementation
+## Goals:
 
-- See test implementation in [`/spec/support/dummy_app/nodes.rb`](https://github.com/rmosolgo/graphql/blob/master/spec/support/nodes.rb)
-- See `graphql-ruby-demo` with Rails on [github](https://github.com/rmosolgo/graphql-ruby-demo) or [heroku](http://graphql-ruby-demo.herokuapp.com/)
-
-<a href="http://graphql-ruby-demo.herokuapp.com/" target="_blank"><img src="https://cloud.githubusercontent.com/assets/2231765/6217972/5d24edda-b5ce-11e4-9e07-3548304af862.png" style="max-width: 800px;"/></a>
-
-
-## Usage
-
-- Implement _nodes_ that wrap objects in your application
-- Implement _calls_ that return those objects (and may mutate the application state)
-- Execute _queries_ and return the result.
-
-### Nodes
-
-Nodes are delegators that wrap objects in your app. You must whitelist fields by declaring them in the class definition.
-
-
-```ruby
-class FishNode < GraphQL::Node
-  exposes "Fish"
-  cursor(:id)
-  field.number(:id)
-  field.string(:name)
-  field.string(:species)
-  # specify an `AquariumNode`:
-  field.aquarium(:aquarium)
-end
-```
-
-You can also declare connections between objects:
-
-```ruby
-class AquariumNode < GraphQL::Node
-  exposes "Aquarium"
-  cursor(:id)
-  field.number(:id)
-  field.number(:occupancy)
-  field.connection(:fishes)
-end
-```
-
-You can make custom connections:
-
-```ruby
-class FishSchoolConnection < GraphQL::Connection
-  type :fish_school # now it is a field type
-  call :largest, -> (prev_value, number)  { fishes.sort_by(&:weight).first(number.to_i) }
-
-  field.number(:count) # delegated to `target`
-  field.boolean(:has_more)
-
-  def has_more
-    # the `largest()` call may have removed some items:
-    target.count < original_target.count
-  end
-end
-```
-
-Then use them:
-
-```ruby
-class AquariumNode < GraphQL::Node
-  field.fish_school(:fishes)
-end
-```
-
-And in queries:
-
-```
-aquarium(1) {
-  name,
-  occupancy,
-  fishes.largest(3) {
-      edges {
-        node { name, species }
-      },
-      count,
-      has_more
-    }
-  }
-}
-```
-
-### Calls
-
-Calls selectively expose your application to the world. They always return values and they may perform mutations.
-
-Calls declare returns, declare arguments, and implement `#execute!`.
-
-This call just finds values:
-
-```ruby
-class FindFishCall < GraphQL::RootCall
-  returns :fish
-  argument.number(:id)
-  def execute!(id)
-    Fish.find(id)
-  end
-end
-```
-
-This call performs a mutation:
-
-```ruby
-class RelocateFishCall < GraphQL::RootCall
-  returns :fish, :previous_aquarium, :new_aquarium
-  argument.number(:fish_id)
-  argument.number(:new_aquarium_id)
-
-  def execute!(fish_id, new_aquarium_id)
-    fish = Fish.find(fish_id)
-
-    # context is defined by the query, see below
-    if !context[:user].can_move?(fish)
-      raise RelocateNotAllowedError
-    end
-
-    previous_aquarium = fish.aquarium
-    new_aquarium = Aquarium.find(new_aquarium_id)
-    fish.update_attributes(aquarium: new_aquarium)
-    {
-      fish: fish,
-      previous_aquarium: previous_aquarium,
-      new_aquarium: new_aquarium,
-    }
-  end
-end
-```
-
-### Queries
-
-When your system is setup, you can perform queries from a string.
-
-```ruby
-query_str = "find_fish(1) { name, species } "
-query     = GraphQL::Query.new(query_str)
-result    = query.as_result
-
-result
-# {
-#   "1" => {
-#     "name" => "Sharky",
-#     "species" => "Goldfish",
-#   }
-# }
-```
-
-Each query may also define a `context` object which will be accessible at every point in execution.
-
-```ruby
-query_str = "move_fish(1, 3) { fish { name }, new_aquarium { occupancy } }"
-query_ctx = {user: current_user, request: request}
-query     = GraphQL::Query.new(query_str, context: query_ctx)
-result    = query.as_result
-
-result
-# {
-#   "fish" => {
-#     "name" => "Sharky"
-#   },
-#   "new_aquarium" => {
-#     "occupancy" => 12
-#   }
-# }
-```
-
-You could do something like this [inside a Rails controller](https://github.com/rmosolgo/graphql-ruby-demo/blob/master/app/controllers/queries_controller.rb#L5).
+- Implement the GraphQL spec & support a Relay front end
+- Provide idiomatic, plain-Ruby API with similarities to reference implementation where possible
+- Support `graphql-rails`