graphql 1.6.4 → 1.6.5

data/spec/graphql/union_type_spec.rb

@@ -26,6 +26,59 @@ describe GraphQL::UnionType do
     assert_equal(false, union.include?(type_3))
   end
 
+  it '#resolve_type raises error if resolved type is not in possible_types' do
+    test_str = 'Hello world'
+    union.resolve_type = ->(value, ctx) {
+      "This is not the types you are looking for"
+    }
+    fake_ctx = OpenStruct.new(query: GraphQL::Query.new(Dummy::Schema, ""))
+
+    assert_raises(RuntimeError) {
+      union.resolve_type(test_str, fake_ctx)
+    }
+  end
+
+  describe "#resolve_type" do
+    let(:result) { Dummy::Schema.execute(query_string) }
+    let(:query_string) {%|
+      {
+        allAnimal {
+          type: __typename
+          ... on Cow {
+            cowName: name
+          }
+          ... on Goat {
+            goatName: name
+          }
+        }
+
+        allAnimalAsCow {
+          type: __typename
+          ... on Cow {
+            name
+          }
+        }
+      }
+    |}
+
+    it 'returns correct types for general schema and specific union' do
+      expected_result = {
+        # When using Query#resolve_type
+        "allAnimal" => [
+          { "type" => "Cow", "cowName" => "Billy" },
+          { "type" => "Goat", "goatName" => "Gilly" }
+        ],
+
+        # When using UnionType#resolve_type
+        "allAnimalAsCow" => [
+          { "type" => "Cow", "name" => "Billy" },
+          { "type" => "Cow", "name" => "Gilly" }
+        ]
+      }
+      assert_equal expected_result, result["data"]
+    end
+  end
+
   describe "typecasting from union to union" do
     let(:result) { Dummy::Schema.execute(query_string) }
     let(:query_string) {%|

data/spec/spec_helper.rb

@@ -6,10 +6,12 @@ require "rails/all"
 require "rails/generators"
 require "jdbc/sqlite3" if RUBY_ENGINE == 'jruby'
 require "sqlite3" if RUBY_ENGINE == 'ruby'
+require "pg" if RUBY_ENGINE == 'ruby'
 require "sequel"
 require "graphql"
 require "graphql/rake_task"
 require "benchmark"
+require "pry"
 require "minitest/autorun"
 require "minitest/focus"
 require "minitest/reporters"
@@ -24,9 +26,11 @@ Minitest.backtrace_filter = Minitest::BacktraceFilter.new
 
 # This is for convenient access to metadata in test definitions
 assign_metadata_key = ->(target, key, value) { target.metadata[key] = value }
+assign_metadata_flag = ->(target, flag) { target.metadata[flag] = true }
 GraphQL::BaseType.accepts_definitions(metadata: assign_metadata_key)
 GraphQL::Field.accepts_definitions(metadata: assign_metadata_key)
 GraphQL::Argument.accepts_definitions(metadata: assign_metadata_key)
+GraphQL::Argument.accepts_definitions(metadata_flag: assign_metadata_flag)
 GraphQL::EnumType::EnumValue.accepts_definitions(metadata: assign_metadata_key)
 
 # Can be used as a GraphQL::Schema::Warden for some purposes, but allows nothing
@@ -36,6 +40,11 @@ module NothingWarden
   end
 end
 
+# Use this when a schema requires a `resolve_type` hook
+# but you know it won't be called
+NO_OP_RESOLVE_TYPE = ->(type, obj, ctx) {
+  raise "this should never be called"
+}
 # Load support files
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 

data/spec/support/dummy/data.rb

@@ -6,6 +6,11 @@ module Dummy
       # This is buggy on purpose -- it shouldn't be called during execution.
       other.id == id
     end
+
+    # Alias for when this is treated as milk in EdibleAsMilkInterface
+    def fatContent # rubocop:disable Style/MethodName
+      fat_content
+    end
   end
 
   CHEESES = {
@@ -25,9 +30,13 @@ module Dummy
     milks: [MILKS[1]]
   )
 
-  COW = OpenStruct.new(
-    id: 1,
-    name: "Billy",
-    last_produced_dairy: MILKS[1]
-  )
+  Cow = Struct.new(:id, :name, :last_produced_dairy)
+  COWS = {
+    1 => Cow.new(1, "Billy", MILKS[1])
+  }
+
+  Goat = Struct.new(:id, :name, :last_produced_dairy)
+  GOATS = {
+    1 => Goat.new(1, "Gilly", MILKS[1]),
+  }
 end

data/spec/support/dummy/schema.rb

@@ -21,6 +21,12 @@ module Dummy
     field :selfAsEdible, EdibleInterface, resolve: ->(o, a, c) { o }
   end
 
+  EdibleAsMilkInterface = EdibleInterface.redefine do
+    name "EdibleAsMilk"
+    description "Milk :+1:"
+    resolve_type ->(obj, ctx) { MilkType }
+  end
+
   AnimalProductInterface = GraphQL::InterfaceType.define do
     name "AnimalProduct"
     description "Comes from an animal, no joke"
@@ -48,7 +54,7 @@ module Dummy
     name "Cheese"
     class_names ["Cheese"]
     description "Cultured dairy product"
-    interfaces [EdibleInterface, AnimalProductInterface, LocalProductInterface]
+    interfaces [EdibleInterface, EdibleAsMilkInterface, AnimalProductInterface, LocalProductInterface]
 
     # Can have (name, type, desc)
     field :id, !types.Int, "Unique identifier"
@@ -96,7 +102,7 @@ module Dummy
   MilkType = GraphQL::ObjectType.define do
     name "Milk"
     description "Dairy beverage"
-    interfaces [EdibleInterface, AnimalProductInterface, LocalProductInterface]
+    interfaces [EdibleInterface, EdibleAsMilkInterface, AnimalProductInterface, LocalProductInterface]
     field :id, !types.ID
     field :source, !DairyAnimalEnum, "Animal which produced this milk", hash_key: :source
     field :origin, !types.String, "Place the milk comes from"
@@ -152,7 +158,7 @@ module Dummy
 
   CowType = GraphQL::ObjectType.define do
     name "Cow"
-    description "A farm where milk is harvested and cheese is produced"
+    description "A bovine animal that produces milk"
     field :id, !types.ID
     field :name, types.String
     field :last_produced_dairy, DairyProductUnion
@@ -168,6 +174,29 @@ module Dummy
     end
   end
 
+  GoatType = GraphQL::ObjectType.define do
+    name "Goat"
+    description "An caprinae animal that produces milk"
+    field :id, !types.ID
+    field :name, types.String
+    field :last_produced_dairy, DairyProductUnion
+  end
+
+  AnimalUnion = GraphQL::UnionType.define do
+    name "Animal"
+    description "Species of living things"
+    possible_types [CowType, GoatType]
+  end
+
+  AnimalAsCowUnion = GraphQL::UnionType.define do
+    name "AnimalAsCow"
+    description "All animals go mooooo!"
+    possible_types [CowType]
+    resolve_type ->(obj, ctx) {
+      CowType
+    }
+  end
+
   ResourceOrderType = GraphQL::InputObjectType.define {
     name "ResourceOrderType"
     description "Properties used to determine ordering"
@@ -271,7 +300,7 @@ module Dummy
     field :dairy, function: GetSingleton.new(type: DairyType, data: DAIRY)
     field :fromSource, &SourceFieldDefn
     field :favoriteEdible, FavoriteFieldDefn
-    field :cow, function: GetSingleton.new(type: CowType, data: COW)
+    field :cow, function: GetSingleton.new(type: CowType, data: COWS[1])
     field :searchDairy do
       description "Find dairy products matching a description"
       type !DairyProductUnion
@@ -287,6 +316,14 @@ module Dummy
       }
     end
 
+    field :allAnimal, !types[AnimalUnion] do
+      resolve ->(obj, args, ctx) { COWS.values + GOATS.values }
+    end
+
+    field :allAnimalAsCow, !types[AnimalAsCowUnion] do
+      resolve ->(obj, args, ctx) { COWS.values + GOATS.values }
+    end
+
     field :allDairy, types[DairyProductUnion] do
       argument :executionErrorAtIndex, types.Int
       resolve ->(obj, args, ctx) {
@@ -300,6 +337,10 @@ module Dummy
       resolve ->(obj, args, ctx) { CHEESES.values + MILKS.values }
     end
 
+    field :allEdibleAsMilk, types[EdibleAsMilkInterface] do
+      resolve ->(obj, args, ctx) { CHEESES.values + MILKS.values }
+    end
+
     field :error do
       description "Raise an error"
       type GraphQL::STRING_TYPE
@@ -375,7 +416,7 @@ module Dummy
 
     rescue_from(NoSuchDairyError) { |err| err.message  }
 
-    resolve_type ->(obj, ctx) {
+    resolve_type ->(type, obj, ctx) {
       Schema.types[obj.class.name.split("::").last]
     }
   end

data/spec/support/star_wars/data.rb

@@ -21,10 +21,20 @@ module StarWars
   # ActiveRecord::Base.logger = Logger.new(STDOUT)
   `rm -f ./_test_.db`
   # Set up "Bases" in ActiveRecord
+
   if jruby?
     ActiveRecord::Base.establish_connection(adapter: "jdbcsqlite3", database: "./_test_.db")
+    Sequel.connect('jdbc:sqlite:./_test_.db')
+  elsif ENV['DATABASE'] == 'POSTGRESQL'
+    ActiveRecord::Base.establish_connection(
+      adapter: "postgresql",
+      username: "postgres",
+      database: "graphql_ruby_test"
+    )
+    DB = Sequel.connect('postgres://postgres:@localhost:5432/graphql_ruby_test')
   else
     ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: "./_test_.db")
+    DB = Sequel.sqlite("./_test_.db")
   end
 
   ActiveRecord::Schema.define do
@@ -46,12 +56,6 @@ module StarWars
   Base.create!(name: "Shield Generator", planet: "Endor", faction_id: 2)
   Base.create!(name: "Headquarters", planet: "Coruscant", faction_id: 2)
 
-  # Also, set up Bases with Sequel
-  DB = if jruby?
-    Sequel.connect('jdbc:sqlite:./_test_.db')
-  else
-    Sequel.sqlite("./_test_.db")
-  end
   class SequelBase < Sequel::Model(:bases)
   end
 

data/spec/support/star_wars/schema.rb

@@ -304,7 +304,10 @@ module StarWars
 
     connection :newestBasesGroupedByFaction, BaseType.connection_type do
       resolve ->(obj, args, ctx) {
-        Base.order('sum(faction_id) desc').group(:faction_id)
+        Base
+          .having('id in (select max(id) from bases group by faction_id)')
+          .group(:id)
+          .order('faction_id desc')
       }
     end
 
@@ -359,7 +362,7 @@ module StarWars
     mutation(MutationType)
     default_max_page_size 3
 
-    resolve_type ->(object, ctx) {
+    resolve_type ->(type, object, ctx) {
       if object == :test_error
         :not_a_type
       elsif object.is_a?(Base)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.6.4
+  version: 1.6.5
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-20 00:00:00.000000000 Z
+date: 2017-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -299,6 +299,7 @@ extra_rdoc_files: []
 files:
 - ".yardopts"
 - MIT-LICENSE
+- lib/generators/graphql/core.rb
 - lib/generators/graphql/enum_generator.rb
 - lib/generators/graphql/function_generator.rb
 - lib/generators/graphql/install_generator.rb
@@ -312,6 +313,7 @@ files:
 - lib/generators/graphql/templates/interface.erb
 - lib/generators/graphql/templates/loader.erb
 - lib/generators/graphql/templates/mutation.erb
+- lib/generators/graphql/templates/mutation_type.erb
 - lib/generators/graphql/templates/object.erb
 - lib/generators/graphql/templates/query_type.erb
 - lib/generators/graphql/templates/schema.erb
@@ -351,6 +353,7 @@ files:
 - lib/graphql/define/assign_object_field.rb
 - lib/graphql/define/defined_object_proxy.rb
 - lib/graphql/define/instance_definable.rb
+- lib/graphql/define/no_definition_error.rb
 - lib/graphql/define/non_null_with_bang.rb
 - lib/graphql/define/type_definer.rb
 - lib/graphql/directive.rb
@@ -465,18 +468,16 @@ files:
 - lib/graphql/schema/catchall_middleware.rb
 - lib/graphql/schema/default_parse_error.rb
 - lib/graphql/schema/default_type_error.rb
-- lib/graphql/schema/instrumented_field_map.rb
 - lib/graphql/schema/invalid_type_error.rb
 - lib/graphql/schema/loader.rb
 - lib/graphql/schema/middleware_chain.rb
 - lib/graphql/schema/null_mask.rb
 - lib/graphql/schema/possible_types.rb
 - lib/graphql/schema/printer.rb
-- lib/graphql/schema/reduce_types.rb
 - lib/graphql/schema/rescue_middleware.rb
 - lib/graphql/schema/timeout_middleware.rb
+- lib/graphql/schema/traversal.rb
 - lib/graphql/schema/type_expression.rb
-- lib/graphql/schema/type_map.rb
 - lib/graphql/schema/unique_within_type.rb
 - lib/graphql/schema/validation.rb
 - lib/graphql/schema/warden.rb
@@ -600,9 +601,9 @@ files:
 - spec/graphql/schema/loader_spec.rb
 - spec/graphql/schema/middleware_chain_spec.rb
 - spec/graphql/schema/printer_spec.rb
-- spec/graphql/schema/reduce_types_spec.rb
 - spec/graphql/schema/rescue_middleware_spec.rb
 - spec/graphql/schema/timeout_middleware_spec.rb
+- spec/graphql/schema/traversal_spec.rb
 - spec/graphql/schema/type_expression_spec.rb
 - spec/graphql/schema/unique_within_type_spec.rb
 - spec/graphql/schema/validation_spec.rb
@@ -750,9 +751,9 @@ test_files:
 - spec/graphql/schema/loader_spec.rb
 - spec/graphql/schema/middleware_chain_spec.rb
 - spec/graphql/schema/printer_spec.rb
-- spec/graphql/schema/reduce_types_spec.rb
 - spec/graphql/schema/rescue_middleware_spec.rb
 - spec/graphql/schema/timeout_middleware_spec.rb
+- spec/graphql/schema/traversal_spec.rb
 - spec/graphql/schema/type_expression_spec.rb
 - spec/graphql/schema/unique_within_type_spec.rb
 - spec/graphql/schema/validation_spec.rb

data/lib/graphql/schema/instrumented_field_map.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Schema
-    # A two-level map with fields as the last values.
-    # The first level is type names, which point to a second map.
-    # The second level is field names, which point to fields.
-    #
-    # The catch is, the fields in this map _may_ have been modified by being instrumented.
-    class InstrumentedFieldMap
-      # Build a map using types from `schema` and instrumenters in `field_instrumenters`
-      # @param schema [GraphQL::Schema]
-      # @param field_instrumenters [Array<#instrument(type, field)>]
-      def initialize(schema, field_instrumenters)
-        @storage = Hash.new { |h, k| h[k] = {} }
-        schema.types.each do |type_name, type|
-          if type.kind.fields?
-            type.all_fields.each do |field_defn|
-              instrumented_field_defn = field_instrumenters.reduce(field_defn) do |defn, inst|
-                inst.instrument(type, defn)
-              end
-              self.set(type.name, field_defn.name, instrumented_field_defn)
-            end
-          end
-        end
-      end
-
-      def set(type_name, field_name, field)
-        @storage[type_name][field_name] = field
-      end
-
-      def get(type_name, field_name)
-        @storage[type_name][field_name]
-      end
-
-      def get_all(type_name)
-        @storage[type_name]
-      end
-    end
-  end
-end

data/lib/graphql/schema/reduce_types.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Schema
-    module ReduceTypes
-      # @param types [Array<GraphQL::BaseType>] members of a schema to crawl for all member types
-      # @return [GraphQL::Schema::TypeMap] `{name => Type}` pairs derived from `types`
-      def self.reduce(types)
-        type_map = GraphQL::Schema::TypeMap.new
-        types.each do |type|
-          reduce_type(type, type_map, type.name)
-        end
-        type_map
-      end
-
-      private
-
-      # Based on `type`, add members to `type_hash`.
-      # If `type` has already been visited, just return the `type_hash` as-is
-      def self.reduce_type(type, type_hash, context_description)
-        if !type.is_a?(GraphQL::BaseType)
-          message = "#{context_description} has an invalid type: must be an instance of GraphQL::BaseType, not #{type.class.inspect} (#{type.inspect})"
-          raise GraphQL::Schema::InvalidTypeError.new(message)
-        end
-
-        type = type.unwrap
-
-        # Don't re-visit a type
-        if !type_hash.fetch(type.name, nil).equal?(type)
-          validate_type(type, context_description)
-          type_hash[type.name] = type
-          crawl_type(type, type_hash, context_description)
-        end
-      end
-
-      def self.crawl_type(type, type_hash, context_description)
-        if type.kind.fields?
-          type.all_fields.each do |field|
-            reduce_type(field.type, type_hash, "Field #{type.name}.#{field.name}")
-            field.arguments.each do |name, argument|
-              reduce_type(argument.type, type_hash, "Argument #{name} on #{type.name}.#{field.name}")
-            end
-          end
-        end
-        if type.kind.object?
-          type.interfaces.each do |interface|
-            reduce_type(interface, type_hash, "Interface on #{type.name}")
-          end
-        end
-        if type.kind.union?
-          type.possible_types.each do |possible_type|
-            reduce_type(possible_type, type_hash, "Possible type for #{type.name}")
-          end
-        end
-        if type.kind.input_object?
-          type.arguments.each do |argument_name, argument|
-            reduce_type(argument.type, type_hash, "Input field #{type.name}.#{argument_name}")
-          end
-        end
-      end
-
-      def self.validate_type(type, context_description)
-        error_message = GraphQL::Schema::Validation.validate(type)
-        if error_message
-          raise GraphQL::Schema::InvalidTypeError.new("#{context_description} is invalid: #{error_message}")
-        end
-      end
-    end
-  end
-end