graphql 0.12.1 → 0.13.0

data/lib/graphql/static_validation/validator.rb

@@ -1,29 +1,33 @@
-# Initialized with a {GraphQL::Schema}, then it can validate {GraphQL::Language::Nodes::Documents}s based on that schema.
-#
-# By default, it's used by {GraphQL::Query}
-#
-# @example Validate a query
-#   validator = GraphQL::StaticValidation::Validator.new(schema: MySchema)
-#   document = GraphQL.parse(query_string)
-#   errors = validator.validate(document)
-#
-class GraphQL::StaticValidation::Validator
-  # @param schema [GraphQL::Schema]
-  # @param rule [Array<#validate(context)>] a list of rules to use when validating
-  def initialize(schema:, rules: GraphQL::StaticValidation::ALL_RULES)
-    @schema = schema
-    @rules = rules
-  end
+module GraphQL
+  module StaticValidation
+    # Initialized with a {GraphQL::Schema}, then it can validate {GraphQL::Language::Nodes::Documents}s based on that schema.
+    #
+    # By default, it's used by {GraphQL::Query}
+    #
+    # @example Validate a query
+    #   validator = GraphQL::StaticValidation::Validator.new(schema: MySchema)
+    #   document = GraphQL.parse(query_string)
+    #   errors = validator.validate(document)
+    #
+    class Validator
+      # @param schema [GraphQL::Schema]
+      # @param rule [Array<#validate(context)>] a list of rules to use when validating
+      def initialize(schema:, rules: GraphQL::StaticValidation::ALL_RULES)
+        @schema = schema
+        @rules = rules
+      end
 
-  # Validate `document` against the schema. Returns an array of message hashes.
-  # @param document [GraphQL::Language::Nodes::Document]
-  # @return [Array<Hash>]
-  def validate(query)
-    context = GraphQL::StaticValidation::ValidationContext.new(query)
-    @rules.each do |rules|
-      rules.new.validate(context)
+      # Validate `document` against the schema. Returns an array of message hashes.
+      # @param document [GraphQL::Language::Nodes::Document]
+      # @return [Array<Hash>]
+      def validate(query)
+        context = GraphQL::StaticValidation::ValidationContext.new(query)
+        @rules.each do |rules|
+          rules.new.validate(context)
+        end
+        context.visitor.visit(query.document)
+        context.errors.map(&:to_h)
+      end
     end
-    context.visitor.visit(query.document)
-    context.errors.map(&:to_h)
   end
 end

data/lib/graphql/type_kinds.rb

@@ -1,46 +1,48 @@
-# Type kinds are the basic categories which a type may belong to (`Object`, `Scalar`, `Union`...)
-module GraphQL::TypeKinds
-  # These objects are singletons, eg `GraphQL::TypeKinds::UNION`, `GraphQL::TypeKinds::SCALAR`.
-  class TypeKind
-    attr_reader :name
-    def initialize(name, resolves: false, fields: false, wraps: false, input: false)
-      @name = name
-      @resolves = resolves
-      @fields = fields
-      @wraps = wraps
-      @input = input
-      @composite = fields? || resolves?
-    end
+module GraphQL
+  # Type kinds are the basic categories which a type may belong to (`Object`, `Scalar`, `Union`...)
+  module TypeKinds
+    # These objects are singletons, eg `GraphQL::TypeKinds::UNION`, `GraphQL::TypeKinds::SCALAR`.
+    class TypeKind
+      attr_reader :name
+      def initialize(name, resolves: false, fields: false, wraps: false, input: false)
+        @name = name
+        @resolves = resolves
+        @fields = fields
+        @wraps = wraps
+        @input = input
+        @composite = fields? || resolves?
+      end
 
-    # Does this TypeKind have multiple possible implementors?
-    def resolves?;  @resolves;  end
-    # Does this TypeKind have queryable fields?
-    def fields?;    @fields;    end
-    # Does this TypeKind modify another type?
-    def wraps?;     @wraps;     end
-    # Is this TypeKind a valid query input?
-    def input?;     @input;     end
-    def to_s;       @name;      end
-    # Is this TypeKind composed of many values?
-    def composite?; @composite; end
-  end
+      # Does this TypeKind have multiple possible implementors?
+      def resolves?;  @resolves;  end
+      # Does this TypeKind have queryable fields?
+      def fields?;    @fields;    end
+      # Does this TypeKind modify another type?
+      def wraps?;     @wraps;     end
+      # Is this TypeKind a valid query input?
+      def input?;     @input;     end
+      def to_s;       @name;      end
+      # Is this TypeKind composed of many values?
+      def composite?; @composite; end
+    end
 
-  TYPE_KINDS = [
-    SCALAR =        TypeKind.new("SCALAR", input: true),
-    OBJECT =        TypeKind.new("OBJECT", fields: true),
-    INTERFACE =     TypeKind.new("INTERFACE", resolves: true, fields: true),
-    UNION =         TypeKind.new("UNION", resolves: true),
-    ENUM =          TypeKind.new("ENUM", input: true),
-    INPUT_OBJECT =  TypeKind.new("INPUT_OBJECT", input: true),
-    LIST =          TypeKind.new("LIST", wraps: true),
-    NON_NULL =      TypeKind.new("NON_NULL", wraps: true),
-  ]
+    TYPE_KINDS = [
+      SCALAR =        TypeKind.new("SCALAR", input: true),
+      OBJECT =        TypeKind.new("OBJECT", fields: true),
+      INTERFACE =     TypeKind.new("INTERFACE", resolves: true, fields: true),
+      UNION =         TypeKind.new("UNION", resolves: true),
+      ENUM =          TypeKind.new("ENUM", input: true),
+      INPUT_OBJECT =  TypeKind.new("INPUT_OBJECT", input: true),
+      LIST =          TypeKind.new("LIST", wraps: true),
+      NON_NULL =      TypeKind.new("NON_NULL", wraps: true),
+    ]
 
-  KIND_NAMES = TYPE_KINDS.map(&:name)
-  class TypeKind
-    KIND_NAMES.each do |kind_name|
-      define_method("#{kind_name.downcase}?") do
-        self.name == kind_name
+    KIND_NAMES = TYPE_KINDS.map(&:name)
+    class TypeKind
+      KIND_NAMES.each do |kind_name|
+        define_method("#{kind_name.downcase}?") do
+          self.name == kind_name
+        end
       end
     end
   end

data/lib/graphql/union_type.rb

@@ -1,19 +1,25 @@
-# A collection of {ObjectType}s
-#
-# @example a union of types
-#
-#   PetUnion = GraphQL::UnionType.define do
-#     name "Pet"
-#     description "Animals that live in your house"
-#     possible_types [DogType, CatType, FishType]
-#   end
-#
-class GraphQL::UnionType < GraphQL::BaseType
-  include GraphQL::BaseType::HasPossibleTypes
-  attr_accessor :name, :description, :possible_types
-  accepts_definitions :possible_types, :resolve_type
+module GraphQL
+  # A collection of {ObjectType}s
+  #
+  # @example a union of types
+  #
+  #   PetUnion = GraphQL::UnionType.define do
+  #     name "Pet"
+  #     description "Animals that live in your house"
+  #     possible_types [DogType, CatType, FishType]
+  #   end
+  #
+  class UnionType < GraphQL::BaseType
+    include GraphQL::BaseType::HasPossibleTypes
+    attr_accessor :name, :description, :possible_types
+    accepts_definitions :possible_types, :resolve_type
 
-  def kind
-    GraphQL::TypeKinds::UNION
+    def kind
+      GraphQL::TypeKinds::UNION
+    end
+
+    def include?(child_type_defn)
+      possible_types.include?(child_type_defn)
+    end
   end
 end

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.12.1"
+  VERSION = "0.13.0"
 end

data/readme.md

@@ -64,10 +64,6 @@ Schema = GraphQL::Schema.new(
 )
 ```
 
-See also:
-  - the [test schema](https://github.com/rmosolgo/graphql-ruby/blob/master/spec/support/dairy_app.rb)
-  - [`graphql-ruby-demo`](https://github.com/rmosolgo/graphql-ruby-demo) for an example schema on Rails
-
 #### Execute queries
 
 Execute GraphQL queries on a given schema, from a query string.
@@ -84,11 +80,6 @@ result_hash = Schema.execute(query_string)
 # }
 ```
 
-See also:
-  - [query_spec.rb](https://github.com/rmosolgo/graphql-ruby/blob/master/spec/graphql/query_spec.rb) for an example of query execution.
-  -  [`queries_controller.rb`](https://github.com/rmosolgo/graphql-ruby-demo/blob/master/app/controllers/queries_controller.rb) for a Rails example
-  - Try it on [heroku](http://graphql-ruby-demo.herokuapp.com)
-
 #### Use with Relay
 
 If you're building a backend for [Relay](http://facebook.github.io/relay/), you'll need:
@@ -96,21 +87,6 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
 - A JSON dump of the schema, which you can get by sending [`GraphQL::Introspection::INTROSPECTION_QUERY`](https://github.com/rmosolgo/graphql-ruby/blob/master/lib/graphql/introspection/introspection_query.rb)
 - Relay-specific helpers for GraphQL like Connections, node fields, and global ids. Here's one example of those: [`graphql-relay`](https://github.com/rmosolgo/graphql-relay-ruby)
 
-## Getting Started Tutorials
-
-#### Series: Building a blog in GraphQL and Relay on Rails
-1. **Introduction:** https://medium.com/@gauravtiwari/graphql-and-relay-on-rails-getting-started-955a49d251de
-2. **Part1:** https://medium.com/@gauravtiwari/graphql-and-relay-on-rails-creating-types-and-schema-b3f9b232ccfc
-3. **Part2:**
-https://medium.com/@gauravtiwari/graphql-and-relay-on-rails-first-relay-powered-react-component-cb3f9ee95eca
-
-#### Tutorials
-
-1. https://medium.com/@khor/relay-facebook-on-rails-8b4af2057152
-2. https://blog.jacobwgillespie.com/from-rest-to-graphql-b4e95e94c26b#.4cjtklrwt
-3. http://mgiroux.me/2015/getting-started-with-rails-graphql-relay/
-4. http://mgiroux.me/2015/uploading-files-using-relay-with-rails/
-
 ## Goals
 
 - Implement the GraphQL spec & support a Relay front end
@@ -126,20 +102,29 @@ https://medium.com/@gauravtiwari/graphql-and-relay-on-rails-first-relay-powered-
 
 ## Related Projects
 
+### Code
+
 - `graphql-ruby` + Rails demo ([src](https://github.com/rmosolgo/graphql-ruby-demo) / [heroku](http://graphql-ruby-demo.herokuapp.com))
 - [`graphql-batch`](https://github.com/shopify/graphql-batch), a batched query execution strategy
-- [`graphql-parallel`](https://github.com/rmosolgo/graphql-parallel), an asynchronous query execution strategy
 - [Example Relay support](https://github.com/rmosolgo/graphql-relay-ruby) in Ruby
 - [`graphql-libgraphqlparser`](https://github.com/rmosolgo/graphql-libgraphqlparser), bindings to [libgraphqlparser](https://github.com/graphql/libgraphqlparser), a C-level parser.
 
+### Blog Posts
+
+-  Building a blog in GraphQL and Relay on Rails [Introduction](https://medium.com/@gauravtiwari/graphql-and-relay-on-rails-getting-started-955a49d251de), [Part 1]( https://medium.com/@gauravtiwari/graphql-and-relay-on-rails-creating-types-and-schema-b3f9b232ccfc), [Part 2](https://medium.com/@gauravtiwari/graphql-and-relay-on-rails-first-relay-powered-react-component-cb3f9ee95eca)
+- https://medium.com/@khor/relay-facebook-on-rails-8b4af2057152
+- https://blog.jacobwgillespie.com/from-rest-to-graphql-b4e95e94c26b#.4cjtklrwt
+- http://mgiroux.me/2015/getting-started-with-rails-graphql-relay/
+- http://mgiroux.me/2015/uploading-files-using-relay-with-rails/
+
 ## To Do
 
-- Interface's possible types should be a property of the schema, not the interface
 - Type lookup should be by type name (to support reloaded constants in Rails code)
 - Add a complexity validator (reject queries if they're too big)
 - Add docs for shared behaviors & DRY code
-- Optimize the pure-Ruby parser (hand-write, RACC?!)
 - Revamp the fixture Schema to be more useful (better names, more extensible)
+- Fix when a field's type is left out `field :name, "This is the name field"`
+- Revisit error handling & `debug:` option
 - __Subscriptions__
   - This is a good chance to make an `Operation` abstraction of which `query`, `mutation` and `subscription` are members
   - For a subscription, `graphql` would send an outbound message to the system (allow the host application to manage its own subscriptions via Pusher, ActionCable, whatever)

data/spec/graphql/base_type_spec.rb

@@ -1,7 +1,7 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe GraphQL::BaseType do
-  it 'becomes non-null with !' do
+  it "becomes non-null with !" do
     type = GraphQL::EnumType.new
     non_null_type = !type
     assert_equal(GraphQL::TypeKinds::NON_NULL, non_null_type.kind)
@@ -9,7 +9,7 @@ describe GraphQL::BaseType do
     assert_equal(GraphQL::TypeKinds::NON_NULL, (!GraphQL::STRING_TYPE).kind)
   end
 
-  it 'can be compared' do
+  it "can be compared" do
     assert_equal(!GraphQL::INT_TYPE, !GraphQL::INT_TYPE)
     refute_equal(!GraphQL::FLOAT_TYPE, GraphQL::FLOAT_TYPE)
     assert_equal(

data/spec/graphql/directive_spec.rb

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe GraphQL::Directive do
   let(:result) { DummySchema.execute(query_string, variables: {"t" => true, "f" => false}) }
-  describe 'on fields' do
+  describe "on fields" do
     let(:query_string) { %|query directives($t: Boolean!, $f: Boolean!) {
       cheese(id: 1) {
         # plain fields:
@@ -23,11 +23,11 @@ describe GraphQL::Directive do
       fragment dontIncludeIdField on Cheese { dontIncludeId: id @include(if: false) }
       fragment skipIdField on Cheese { skipId: id @skip(if: true) }
       fragment dontSkipIdField on Cheese { dontSkipId: id @skip(if: false) }
-    |}
-    it 'intercepts fields' do
+    |
+    }
+    it "intercepts fields" do
       expected = { "data" =>{
         "cheese" => {
-          "dontSkipDontIncludeFlavor" => "Brie", #skip has precedence over include
           "dontSkipFlavor" => "Brie",
           "includeFlavor" => "Brie",
           "includeId" => 1,
@@ -37,7 +37,7 @@ describe GraphQL::Directive do
       assert_equal(expected, result)
     end
   end
-  describe 'on fragments' do
+  describe "on fragments spreads and inline fragments" do
     let(:query_string) { %|query directives {
       cheese(id: 1) {
         ... skipFlavorField @skip(if: true)
@@ -45,37 +45,29 @@ describe GraphQL::Directive do
         ... includeFlavorField @include(if: true)
         ... dontIncludeFlavorField @include(if: false)
 
-        ... includeIdField
-        ... dontIncludeIdField
-        ... skipIdField
-        ... dontSkipIdField
 
         ... on Cheese @skip(if: true) { skipInlineId: id }
         ... on Cheese @skip(if: false) { dontSkipInlineId: id }
         ... on Cheese @include(if: true) { includeInlineId: id }
         ... on Cheese @include(if: false) { dontIncludeInlineId: id }
+        ... @skip(if: true) { skipNoType: id }
+        ... @skip(if: false) { dontSkipNoType: id }
         }
       }
       fragment includeFlavorField on Cheese { includeFlavor: flavor  }
       fragment dontIncludeFlavorField on Cheese { dontIncludeFlavor: flavor  }
       fragment skipFlavorField on Cheese { skipFlavor: flavor  }
       fragment dontSkipFlavorField on Cheese { dontSkipFlavor: flavor }
-
-      fragment includeIdField on Cheese @include(if: true) { includeId: id  }
-      fragment dontIncludeIdField on Cheese @include(if: false) { dontIncludeId: id  }
-      fragment skipIdField on Cheese @skip(if: true) { skipId: id  }
-      fragment dontSkipIdField on Cheese @skip(if: false) { dontSkipId: id }
     |}
 
-    it 'intercepts fragment spreads' do
+    it "intercepts fragment spreads" do
       expected = { "data" => {
         "cheese" => {
           "dontSkipFlavor" => "Brie",
           "includeFlavor" => "Brie",
-          "includeId" => 1,
-          "dontSkipId" => 1,
           "dontSkipInlineId" => 1,
           "includeInlineId" => 1,
+          "dontSkipNoType" => 1,
         },
       }}
       assert_equal(expected, result)

data/spec/graphql/enum_type_spec.rb

@@ -1,9 +1,9 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe GraphQL::EnumType do
   let(:enum) { DairyAnimalEnum }
 
-  it 'coerces names to underlying values' do
+  it "coerces names to underlying values" do
     assert_equal("YAK", enum.coerce_input("YAK"))
     assert_equal(1, enum.coerce_input("COW"))
   end
@@ -13,14 +13,14 @@ describe GraphQL::EnumType do
     assert_equal("COW", enum.coerce_result(1))
   end
 
-  it 'has value description' do
-    assert_equal("Animal with horns", enum.values['GOAT'].description)
+  it "has value description" do
+    assert_equal("Animal with horns", enum.values["GOAT"].description)
   end
 
-  describe 'validate_input with bad input' do
-    let(:result) { DairyAnimalEnum.validate_input('bad enum') }
+  describe "validate_input with bad input" do
+    let(:result) { DairyAnimalEnum.validate_input("bad enum") }
 
-    it 'returns an invalid result' do
+    it "returns an invalid result" do
       assert(!result.valid?)
     end
   end

data/spec/graphql/execution_error_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe GraphQL::ExecutionError do
   let(:result) { DummySchema.execute(query_string) }

data/spec/graphql/field_spec.rb

@@ -1,7 +1,7 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe GraphQL::Field do
-  it 'accepts a proc as type' do
+  it "accepts a proc as type" do
     field = GraphQL::Field.define do
       type(-> { DairyProductUnion })
     end
@@ -18,27 +18,28 @@ describe GraphQL::Field do
   end
 
 
-  describe '.property ' do
+  describe ".property " do
     let(:field) do
       GraphQL::Field.define do
-        name 'field_name'
+        name "field_name"
         # satisfies 'can define by config' below
         property :internal_prop
       end
     end
 
-    it 'can define by config' do
+    it "can define by config" do
       assert_equal(field.property, :internal_prop)
     end
 
-    it 'has nil property if not defined' do
+    it "has nil property if not defined" do
       no_prop_field = GraphQL::Field.define { }
       assert_equal(no_prop_field.property, nil)
     end
 
-    describe 'default resolver' do
+    describe "default resolver" do
       def acts_like_default_resolver(field, old_prop, new_prop)
-        object = OpenStruct.new(old_prop => 'old value', new_prop => 'new value', field.name.to_sym => 'unset value')
+        object = OpenStruct.new(old_prop => "old value", new_prop => "new value", field.name.to_sym => "unset value")
+
 
         old_result = field.resolve(object, nil, nil)
         field.property = new_prop
@@ -46,16 +47,16 @@ describe GraphQL::Field do
         field.property = nil
         unset_result = field.resolve(object, nil, nil)
 
-        assert_equal(old_result, 'old value')
-        assert_equal(new_result, 'new value')
-        assert_equal(unset_result, 'unset value')
+        assert_equal(old_result, "old value")
+        assert_equal(new_result, "new value")
+        assert_equal(unset_result, "unset value")
       end
 
-      it 'responds to changes in property' do
+      it "responds to changes in property" do
         acts_like_default_resolver(field, :internal_prop, :new_prop)
       end
 
-      it 'is reassigned if resolve is set to nil' do
+      it "is reassigned if resolve is set to nil" do
         field.resolve = nil
         acts_like_default_resolver(field, :internal_prop, :new_prop)
       end