graphql 0.12.0 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b779fe5af77f89213fae236cb0e7441bdfe4b0c1
-  data.tar.gz: 457dc5cb4468a2c57f758162dc112db07e0801df
+  metadata.gz: 6682396f1618ee3660ec3120bf597c109d0e2752
+  data.tar.gz: 93a3813ff37f3eb9f4e447eda9aabd3db2688de3
 SHA512:
-  metadata.gz: 1910cea7688e8ddd090ee5e7d64300a6ae39524e2ad5677a0552072ba4704a20213cbd25b9889900bcb2b610b6ff5aedfd9c2757614715aaf44ca4535a091ccd
-  data.tar.gz: cfcbe1c03d9fd8b9ed510af1d64d24dacaf147b337d383eb7de6c596ed200f6a8c2b3c87deef8dfab3cdb7b421811d034a4516c3c6db0e3af089b94758d8cc16
+  metadata.gz: 09eb390035a47146f403a393c1695d7d6355a7d7573c70a277547113f2abad887cded1bb275fa7865c57df5631119487fdd3e50ddf859e705960fc0f67c8fe6e
+  data.tar.gz: d4bef1a775db4a7bd2d58a60c283bce67942ab41bfb551d3d1a7f8080ecdcfc2959d7c0f51872cb80016e77cca68bd04fbede2479217c4b994e6919fb68f86e8

data/lib/graphql/schema.rb

@@ -18,11 +18,14 @@ class GraphQL::Schema
   # @param query [GraphQL::ObjectType]  the query root for the schema
   # @param mutation [GraphQL::ObjectType] the mutation root for the schema
   # @param subscription [GraphQL::ObjectType] the subscription root for the schema
-  def initialize(query:, mutation: nil, subscription: nil, max_depth: nil)
+  # @param max_depth [Integer] maximum query nesting (if it's greater, raise an error)
+  # @param types [Array<GraphQL::BaseType>] additional types to include in this schema
+  def initialize(query:, mutation: nil, subscription: nil, max_depth: nil, types: [])
     @query    = query
     @mutation = mutation
     @subscription = subscription
     @max_depth = max_depth
+    @orphan_types = types
     @directives = DIRECTIVES.reduce({}) { |m, d| m[d.name] = d; m }
     @static_validator = GraphQL::StaticValidation::Validator.new(schema: self)
     @rescue_middleware = GraphQL::Schema::RescueMiddleware.new
@@ -37,7 +40,10 @@ class GraphQL::Schema
 
   # @return [GraphQL::Schema::TypeMap] `{ name => type }` pairs of types in this schema
   def types
-    @types ||= TypeReducer.find_all([query, mutation, GraphQL::Introspection::SchemaType].compact)
+    @types ||= begin
+      all_types = @orphan_types + [query, mutation, GraphQL::Introspection::SchemaType]
+      TypeReducer.find_all(all_types.compact)
+    end
   end
 
   # Execute a query on itself.

data/lib/graphql/schema/type_map.rb

@@ -8,10 +8,14 @@ module GraphQL
     # If you want a type, but want to handle the undefined case, use {#fetch}.
     class TypeMap
       extend Forwardable
-      def_delegators :@storage, :key?, :keys, :values
+      def_delegators :@storage, :key?, :keys, :values, :fetch, :to_h
+
+      # Used for detecting deprecated interface member inferrance
+      attr_accessor :safely_discovered_types
 
       def initialize
         @storage = {}
+        @safely_discovered_types = []
       end
 
       def [](key)
@@ -26,8 +30,11 @@ module GraphQL
         end
       end
 
-      def fetch(key, fallback_value)
-        @storage.key?(key) ? @storage[key] : fallback_value
+      def warnings
+        interface_only_types = @storage.values - safely_discovered_types
+        interface_only_types.map do |unsafe_type|
+          "Type \"#{unsafe_type}\" was inferred from an interface's #possible_types. This won't be supported in the next version of GraphQL. Pass this type with the `types:` argument to `Schema.new` instead!"
+        end
       end
     end
   end

data/lib/graphql/schema/type_reducer.rb

@@ -21,8 +21,13 @@ class GraphQL::Schema::TypeReducer
   def self.find_all(types)
     type_map = GraphQL::Schema::TypeMap.new
     types.reduce(type_map) do |memo, type|
-      self.new(type, memo).result
+      type_map.safely_discovered_types << type
+      self.new(type.unwrap, memo).result
     end
+    type_map.warnings.each do |warning|
+      warn(warning)
+    end
+    type_map
   end
 
   private
@@ -34,22 +39,29 @@ class GraphQL::Schema::TypeReducer
         reduce_type(field.type, type_hash)
         field.arguments.each do |name, argument|
           reduce_type(argument.type, type_hash)
+          safely_discovered(type_hash, argument.type)
         end
+        safely_discovered(type_hash, field.type)
       end
     end
     if type.kind.object?
       type.interfaces.each do |interface|
         reduce_type(interface, type_hash)
+        safely_discovered(type_hash, interface)
       end
     end
     if type.kind.resolves?
       type.possible_types.each do |possible_type|
         reduce_type(possible_type, type_hash)
+        if type.kind.union?
+          safely_discovered(type_hash, possible_type)
+        end
       end
     end
     if type.kind.input_object?
       type.input_fields.each do |name, input_field|
         reduce_type(input_field.type, type_hash)
+        safely_discovered(type_hash, input_field.type)
       end
     end
 
@@ -72,4 +84,12 @@ class GraphQL::Schema::TypeReducer
       raise GraphQL::Schema::InvalidTypeError.new(type, errors)
     end
   end
+
+  def safely_discovered(type_hash, type)
+    inner_type = type.unwrap
+    if !type_hash.safely_discovered_types.include?(inner_type)
+
+      type_hash.safely_discovered_types << inner_type
+    end
+  end
 end

data/lib/graphql/version.rb

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

data/spec/graphql/interface_type_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe GraphQL::InterfaceType do
   let(:interface) { EdibleInterface }
   it 'has possible types' do
-    assert_equal([CheeseType, MilkType], interface.possible_types)
+    assert_equal([CheeseType, MilkType, HoneyType], interface.possible_types)
   end
 
   it 'resolves types for objects' do

data/spec/graphql/introspection/type_type_spec.rb

@@ -57,7 +57,7 @@ describe GraphQL::Introspection::TypeType do
       "animalProduct" => {
         "name"=>"AnimalProduct",
         "kind"=>"INTERFACE",
-        "possibleTypes"=>[{"name"=>"Cheese"}, {"name"=>"Milk"}],
+        "possibleTypes"=>[{"name"=>"Cheese"}, {"name"=>"Milk"}, {"name"=>"Honey"}],
         "fields"=>[
           {"name"=>"source"},
         ]

data/spec/graphql/schema/type_reducer_spec.rb

@@ -1,8 +1,9 @@
 require 'spec_helper'
 
 describe GraphQL::Schema::TypeReducer do
+  let(:type_map) { GraphQL::Schema::TypeMap.new }
   it 'finds types from a single type and its fields' do
-    reducer = GraphQL::Schema::TypeReducer.new(CheeseType, {})
+    reducer = GraphQL::Schema::TypeReducer.new(CheeseType, type_map)
     expected = {
       "Cheese" => CheeseType,
       "Float" => GraphQL::FLOAT_TYPE,
@@ -13,13 +14,14 @@ describe GraphQL::Schema::TypeReducer do
       "Milk" => MilkType,
       "ID" => GraphQL::ID_TYPE,
       "AnimalProduct" => AnimalProductInterface,
+      "Honey" => HoneyType,
     }
     assert_equal(expected.keys, reducer.result.keys)
-    assert_equal(expected, reducer.result)
+    assert_equal(expected, reducer.result.to_h)
   end
 
   it 'finds type from arguments' do
-    reducer = GraphQL::Schema::TypeReducer.new(QueryType, {})
+    reducer = GraphQL::Schema::TypeReducer.new(QueryType, type_map)
     assert_equal(DairyProductInputType, reducer.result["DairyProductInput"])
   end
 
@@ -34,13 +36,13 @@ describe GraphQL::Schema::TypeReducer do
       input_field :child, type_child
     end
 
-    reducer = GraphQL::Schema::TypeReducer.new(type_parent, {})
+    reducer = GraphQL::Schema::TypeReducer.new(type_parent, type_map)
     expected = {
       "InputTypeParent" => type_parent,
       "InputTypeChild" => type_child,
       "String" => GraphQL::STRING_TYPE
     }
-    assert_equal(expected, reducer.result)
+    assert_equal(expected, reducer.result.to_h)
   end
 
   describe 'when a type is invalid' do
@@ -59,12 +61,12 @@ describe GraphQL::Schema::TypeReducer do
     }
 
     it 'raises an InvalidTypeError when passed nil' do
-      reducer = GraphQL::Schema::TypeReducer.new(invalid_type, {})
+      reducer = GraphQL::Schema::TypeReducer.new(invalid_type, type_map)
       assert_raises(GraphQL::Schema::InvalidTypeError) { reducer.result }
     end
 
     it 'raises an InvalidTypeError when passed an object that isnt a GraphQL::BaseType' do
-      reducer = GraphQL::Schema::TypeReducer.new(another_invalid_type, {})
+      reducer = GraphQL::Schema::TypeReducer.new(another_invalid_type, type_map)
       assert_raises(GraphQL::Schema::InvalidTypeError) { reducer.result }
     end
   end
@@ -93,4 +95,21 @@ describe GraphQL::Schema::TypeReducer do
       assert_raises(RuntimeError) { type_map["SomeType"] }
     end
   end
+
+  describe "when a type can only be inferred through an interface" do
+    it "logs a warning" do
+      out, err = capture_io do
+         GraphQL::Schema::TypeReducer.find_all([EdibleInterface])
+      end
+      assert_match /Type "Milk" was inferred from an interface/, err
+      assert_match /Type "Honey" was inferred from an interface/, err
+    end
+
+    it "is ok if the types are passed in explicitly" do
+      out, err = capture_io do
+         GraphQL::Schema::TypeReducer.find_all([EdibleInterface, HoneyType, MilkType])
+      end
+      assert_equal "", err
+    end
+  end
 end

data/spec/support/dairy_app.rb

@@ -73,6 +73,13 @@ MilkType = GraphQL::ObjectType.define do
   end
 end
 
+# No actual data; This type is an "orphan", only accessible through Interfaces
+HoneyType = GraphQL::ObjectType.define do
+  name 'Honey'
+  description "Sweet, dehydrated bee barf"
+  interfaces [EdibleInterface, AnimalProductInterface]
+end
+
 DairyType = GraphQL::ObjectType.define do
   name 'Dairy'
   description 'A farm where milk is harvested and cheese is produced'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.12.1
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-20 00:00:00.000000000 Z
+date: 2016-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -94,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -243,7 +257,6 @@ files:
 - lib/graphql/static_validation.rb
 - lib/graphql/static_validation/all_rules.rb
 - lib/graphql/static_validation/arguments_validator.rb
-- lib/graphql/static_validation/complexity_validator.rb
 - lib/graphql/static_validation/literal_validator.rb
 - lib/graphql/static_validation/message.rb
 - lib/graphql/static_validation/rules/argument_literals_are_compatible.rb
@@ -310,7 +323,6 @@ files:
 - spec/graphql/schema/type_reducer_spec.rb
 - spec/graphql/schema/type_validator_spec.rb
 - spec/graphql/schema_spec.rb
-- spec/graphql/static_validation/complexity_validator_spec.rb
 - spec/graphql/static_validation/rules/argument_literals_are_compatible_spec.rb
 - spec/graphql/static_validation/rules/arguments_are_defined_spec.rb
 - spec/graphql/static_validation/rules/directives_are_defined_spec.rb
@@ -333,7 +345,6 @@ files:
 - spec/graphql/string_type_spec.rb
 - spec/graphql/union_type_spec.rb
 - spec/spec_helper.rb
-- spec/support/calculator_schema.rb
 - spec/support/dairy_app.rb
 - spec/support/dairy_data.rb
 - spec/support/minimum_input_object.rb
@@ -403,7 +414,6 @@ test_files:
 - spec/graphql/schema/type_reducer_spec.rb
 - spec/graphql/schema/type_validator_spec.rb
 - spec/graphql/schema_spec.rb
-- spec/graphql/static_validation/complexity_validator_spec.rb
 - spec/graphql/static_validation/rules/argument_literals_are_compatible_spec.rb
 - spec/graphql/static_validation/rules/arguments_are_defined_spec.rb
 - spec/graphql/static_validation/rules/directives_are_defined_spec.rb
@@ -426,7 +436,6 @@ test_files:
 - spec/graphql/string_type_spec.rb
 - spec/graphql/union_type_spec.rb
 - spec/spec_helper.rb
-- spec/support/calculator_schema.rb
 - spec/support/dairy_app.rb
 - spec/support/dairy_data.rb
 - spec/support/minimum_input_object.rb

data/lib/graphql/static_validation/complexity_validator.rb

@@ -1,27 +0,0 @@
-class GraphQL::StaticValidation::ComplexityValidator
-  include GraphQL::StaticValidation::Message::MessageHelper
-
-  def initialize(max_fields:, list_multiplier:)
-    @max_fields = max_fields
-    @list_multiplier = list_multiplier
-  end
-
-  def validate(context)
-    visitor = context.visitor
-    complexity = 0
-    visitor[GraphQL::Language::Nodes::Field] << -> (node, parent) {
-      field_type = field_definition.type
-      if field_type.kind.list?
-        complexity += list_multiplier
-      else
-        complexity += 1
-      end
-    }
-
-    visitor[GraphQL::Language::Nodes::Document].exit << -> (node, parent) {
-      if complexity > @max_fields
-        context.errors << message("This query is too complex. Request fewer fields.", node)
-      end
-    }
-  end
-end

data/spec/graphql/static_validation/complexity_validator_spec.rb

@@ -1,15 +0,0 @@
-# require "spec_helper"
-#
-# describe GraphQL::StaticValidation::ComplexityValidator do
-#   let(:query_string) {query_string)}
-#   let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [complexity_validator]) }
-#   let(:errors) { validator.validate(document) }
-#   let(:complexity_validator) { GraphQL::StaticValidation::ComplexityValidator.new(max_fields: 6, list_multiplier: 2) }
-#
-#   describe "too many fields" do
-#     it "adds errors if there are too many fields"
-#     it "counts fields for each time they're included from fragments"
-#   end
-#
-#   it "multiplies fields inside list types"
-# end

data/spec/support/calculator_schema.rb

@@ -1,74 +0,0 @@
-# This GraphQL Schema performs operations on numbers.
-# It can perform operations on values you give it and return values
-# It also maintains some state which can be updated or read
-module Calculator
-  # You can reduce a list of values to a single value
-  REDUCERS = {
-    "SUM" => -> (values) { [values.inject(&:+)] },
-    "MAX" => :max.to_proc,
-    "MIN" => :min.to_proc,
-  }
-
-  ReducerEnum = GraphQL::EnumType.define do
-    REDUCERS.map do |op_name, op_proc|
-      value(op_name)
-    end
-  end
-
-  # You can make a new list by transforming each member
-  MAPPERS = {
-    "ADD" => -> (val, arg) { val + arg },
-    "SUB" => -> (val, arg) { val - arg },
-    "EQ" => -> (val, arg) { val == arg ? 1 : 0},
-  }
-
-  MapperEnum = GraphQL::EnumType.define do
-    MAPPERS.map do |op_name, op_proc|
-      value(op_name)
-    end
-  end
-
-  # Input a list of integers
-  ListOfInts = GraphQL::INT_TYPE.to_list_type
-
-  # Expose a list of values and perform operations
-  ValuesType = GraphQL::ObjectType.define do
-    field :values, ListOfInts do
-      resolve -> (obj, _args, _ctx) { obj }
-    end
-
-    # Get a single value based on the values in this list
-    field :reduce, types.Int do
-      argument :operation, !ReducerEnum
-      resolve -> (obj, args, ctx)  {
-        reduce_name = args[:operation]
-        reduce_fn = REDUCERS[reduce_name]
-        reduce_fn.call(obj)
-      }
-    end
-
-    # Handle self-referential fields by wrapping the type in a proc.
-    # It will be lazy-eval'ed
-    field :map, -> { ValuesType } do
-      argument :operation, !MapperEnum
-      argument :argument, !types.Int
-      resolve -> (obj, args, ctx) {
-        op_arg = args[:argument]
-        op_name = args[:operation]
-        op_func = MAPPERS[op_name]
-        obj.map { |item| op_func.call(item, op_arg) }
-      }
-    end
-  end
-
-  QueryType = GraphQL::ObjectType.define do
-    name("Query")
-
-    field :perform, ValuesType do
-      argument :initial, !ListOfInts
-      resolve -> (obj, args, ctx) { args[:initial] }
-    end
-  end
-
-  Schema = GraphQL::Schema.new(query: QueryType)
-end