graphql 0.18.2 → 0.18.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c25c28ed78a94aead6ff0547d559c15b3c00c01f
-  data.tar.gz: 81c73c51e31e934391e9da8daa3d6915acaccb67
+  metadata.gz: e542df508ad2037e784439e944e47df3711dc7b7
+  data.tar.gz: 4623d2ac01705a25245a114aec72a71117172c77
 SHA512:
-  metadata.gz: 3189f4d3b79efdf1082168bcf338159f6a89f04ba0c51d78ca35e64a1284438b08b3424d181db23d8e01c3505fa83cb8c915dc9d8a419cb1d91dbe0af0166d06
-  data.tar.gz: f1a2c37b55214c42258b3f708d15a1dbe33d5bb0e01a8333d0818e494a96319f92d7e942c6efb71591596eafbd9c8e6f108042b928ea1c5631c295c483f86886
+  metadata.gz: d2b6f96474c81050d2f626e62ab96c784459662f3676c6b4a28ea8d36def062e5de6b1cefa097705f6c93be2b026dfb6cea1184b9e736d9fd0618024442b8d83
+  data.tar.gz: de4ea313f70e012ad7152a71dbfe459d62fa4988b43f6947791d00c1fa45eb377962331e8db7f504a96ca331d27d962933874af4afae405a4794be2c82c2d714

data/lib/graphql/execution/typecast.rb

@@ -1,28 +1,32 @@
 module GraphQL
   module Execution
-    # GraphQL object `{value, type}` can be cast to `other_type` when:
-    # - `type == other_type`
-    # - `type` is a union and it resolves `value` to `other_type`
-    # - `other_type` is a union and `type` is a member
-    # - `type` is an interface and it resolves `value` to `other_type`
-    # - `other_type` is an interface and `type` implements that interface
+    # GraphQL object `{value, current_type}` can be cast to `potential_type` when:
+    # - `current_type == potential_type`
+    # - `current_type` is a union and it contains `potential_type`
+    # - `potential_type` is a union and it contains `current_type`
+    # - `current_type` is an interface and `potential_type` implements it
+    # - `potential_type` is an interface and `current_type` implements it
     module Typecast
       # While `value` is exposed by GraphQL as an instance of `current_type`,
       # should it _also_ be treated as an instance of `potential_type`?
       #
       # This is used for checking whether fragments apply to an object.
       #
-      # @return [Boolean] Can `value` be evaluated as a `potential_type`?
-      def self.compatible?(value, current_type, potential_type, query_ctx)
-        if potential_type == current_type
+      # @param [Object] the value which GraphQL is currently exposing
+      # @param [GraphQL::BaseType] the type which GraphQL is using for `value` now
+      # @param [GraphQL::BaseType] can `value` be exposed using this type?
+      # @param [GraphQL::Query::Context] the context for the current query
+      # @return [Boolean] true if `value` be evaluated as a `potential_type`
+      def self.compatible?(current_type, potential_type, query_ctx)
+        if current_type == potential_type
           true
         elsif current_type.kind.union?
-          current_type.resolve_type(value, query_ctx) == potential_type
+          current_type.possible_types.include?(potential_type)
         elsif potential_type.kind.union?
           potential_type.include?(current_type)
-        elsif current_type.kind.interface?
-          current_type.resolve_type(value, query_ctx) == potential_type
-        elsif potential_type.kind.interface?
+        elsif current_type.kind.interface? && potential_type.kind.object?
+          potential_type.interfaces.include?(current_type)
+        elsif potential_type.kind.interface? && current_type.kind.object?
           current_type.interfaces.include?(potential_type)
         else
           false

data/lib/graphql/query/serial_execution/selection_resolution.rb

@@ -13,7 +13,7 @@ module GraphQL
 
         def result
           irep_node.children.each_with_object({}) do |(name, irep_node), memo|
-            if GraphQL::Execution::DirectiveChecks.include?(irep_node, execution_context.query) && applies_to_type?(irep_node, type, target)
+            if GraphQL::Execution::DirectiveChecks.include?(irep_node, execution_context.query) && applies_to_type?(irep_node, type)
               field_result = execution_context.strategy.field_resolution.new(
                 irep_node,
                 type,
@@ -27,9 +27,9 @@ module GraphQL
 
         private
 
-        def applies_to_type?(irep_node, type, target)
-          irep_node.definitions.any? { |child_type, field_defn|
-            GraphQL::Execution::Typecast.compatible?(target, child_type, type, execution_context.query.context)
+        def applies_to_type?(irep_node, current_type)
+          irep_node.definitions.any? { |potential_type, field_defn|
+            GraphQL::Execution::Typecast.compatible?(current_type, potential_type, execution_context.query.context)
           }
         end
       end

data/lib/graphql/relay/base_connection.rb

@@ -61,7 +61,7 @@ module GraphQL
       # @param field [Object] The underlying field
       # @param max_page_size [Int] The maximum number of results to return
       # @param parent [Object] The object which this collection belongs to
-      def initialize(nodes, arguments, field:, max_page_size: nil, parent: nil)
+      def initialize(nodes, arguments, field: nil, max_page_size: nil, parent: nil)
         @nodes = nodes
         @arguments = arguments
         @max_page_size = max_page_size

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.18.2"
+  VERSION = "0.18.3"
 end

data/spec/graphql/execution/typecast_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe GraphQL::Execution::Typecast do
+  let(:milk_value) { MILKS[1] }
+  let(:cheese_value) { CHEESES[1] }
+
+  let(:schema) { DummySchema }
+  let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil) }
+
+  def compatible?(*args)
+    GraphQL::Execution::Typecast.compatible?(*args)
+  end
+
+  it "resolves correctly when both types are the same" do
+    assert compatible?(MilkType, MilkType, context)
+
+    assert !compatible?(MilkType, CheeseType, context)
+  end
+
+  it "resolves a union type to a matching member" do
+    assert compatible?(DairyProductUnion, MilkType, context)
+    assert compatible?(DairyProductUnion, CheeseType, context)
+
+    assert !compatible?(DairyProductUnion, GraphQL::INT_TYPE, context)
+    assert !compatible?(DairyProductUnion, HoneyType, context)
+  end
+
+  it "resolves correcty when potential type is UnionType and current type is a member of that union" do
+    assert compatible?(MilkType, DairyProductUnion, context)
+    assert compatible?(CheeseType, DairyProductUnion, context)
+
+    assert !compatible?(QueryType, DairyProductUnion, context)
+    assert !compatible?(EdibleInterface, DairyProductUnion, context)
+  end
+
+  it "resolves an object type to one of its interfaces" do
+    assert compatible?(CheeseType, EdibleInterface, context)
+    assert compatible?(MilkType, EdibleInterface, context)
+
+    assert !compatible?(QueryType, EdibleInterface, context)
+    assert !compatible?(LocalProductInterface, EdibleInterface, context)
+  end
+
+  it "resolves an interface to a matching member" do
+    assert compatible?(EdibleInterface, CheeseType, context)
+    assert compatible?(EdibleInterface, MilkType, context)
+
+    assert !compatible?(EdibleInterface, GraphQL::STRING_TYPE, context)
+    assert !compatible?(EdibleInterface, DairyProductInputType, context)
+  end
+end

data/spec/graphql/interface_type_spec.rb

@@ -53,4 +53,53 @@ describe GraphQL::InterfaceType do
       assert_equal(interface.resolve_type(123, nil), :custom_resolve)
     end
   end
+
+  describe "fragments" do
+    let(:query_string) {%|
+    {
+      favoriteEdible {
+        fatContent
+        ... on LocalProduct {
+          origin
+        }
+      }
+    }
+    |}
+    let(:result) { DummySchema.execute(query_string) }
+
+    it "can apply interface fragments to an interface" do
+      expected_result = { "data" => {
+        "favoriteEdible" => {
+          "fatContent" => 0.04,
+          "origin" => "Antiquity",
+        }
+      } }
+
+      assert_equal(expected_result, result)
+    end
+
+    describe "filtering members by type" do
+      let(:query_string) {%|
+      {
+        allEdible {
+          __typename
+          ... on LocalProduct {
+            origin
+          }
+        }
+      }
+      |}
+
+      it "only applies fields to the right object" do
+        expected_data = [
+          {"__typename"=>"Cheese", "origin"=>"France"},
+          {"__typename"=>"Cheese", "origin"=>"Netherlands"},
+          {"__typename"=>"Cheese", "origin"=>"Spain"},
+          {"__typename"=>"Milk", "origin"=>"Antiquity"},
+        ]
+
+        assert_equal expected_data, result["data"]["allEdible"]
+      end
+    end
+  end
 end

data/spec/graphql/introspection/schema_type_spec.rb

@@ -19,6 +19,7 @@ describe GraphQL::Introspection::SchemaType do
         "queryType"=>{
           "fields"=>[
             {"name"=>"allDairy"},
+            {"name"=>"allEdible"},
             {"name"=>"cheese"},
             {"name"=>"cow"},
             {"name"=>"dairy"},

data/spec/graphql/introspection/type_type_spec.rb

@@ -36,7 +36,8 @@ describe GraphQL::Introspection::TypeType do
       "milkType"=>{
         "interfaces"=>[
           {"name"=>"Edible"},
-          {"name"=>"AnimalProduct"}
+          {"name"=>"AnimalProduct"},
+          {"name"=>"LocalProduct"},
         ],
         "fields"=>[
           {"type"=>{"name"=>"Non-Null", "ofType"=>{"name"=>"Float"}}},

data/spec/graphql/object_type_spec.rb

@@ -15,7 +15,7 @@ describe GraphQL::ObjectType do
   end
 
   it "may have interfaces" do
-    assert_equal([EdibleInterface, AnimalProductInterface], type.interfaces)
+    assert_equal([EdibleInterface, AnimalProductInterface, LocalProductInterface], type.interfaces)
   end
 
   describe '#get_field ' do

data/spec/graphql/relay/mutation_spec.rb

@@ -5,7 +5,9 @@ describe GraphQL::Relay::Mutation do
     mutation addBagel($clientMutationId: String) {
       introduceShip(input: {shipName: "Bagel", factionId: "1", clientMutationId: $clientMutationId}) {
         clientMutationId
-        ship { name, id }
+        shipEdge {
+          node { name, id }
+        }
         faction { name }
       }
     }
@@ -28,9 +30,11 @@ describe GraphQL::Relay::Mutation do
     expected = {"data" => {
       "introduceShip" => {
         "clientMutationId" => "1234",
-        "ship" => {
-          "name" => "Bagel",
-          "id" => NodeIdentification.to_global_id("Ship", "9"),
+        "shipEdge" => {
+          "node" => {
+            "name" => "Bagel",
+            "id" => NodeIdentification.to_global_id("Ship", "9"),
+          },
         },
         "faction" => {"name" => STAR_WARS_DATA["Faction"]["1"].name }
       }
@@ -40,16 +44,7 @@ describe GraphQL::Relay::Mutation do
 
   it "doesn't require a clientMutationId to perform mutations" do
     result = query(query_string)
-    expected = {"data" => {
-      "introduceShip" => {
-        "clientMutationId" => nil,
-        "ship" => {
-          "name" => "Bagel",
-          "id" => NodeIdentification.to_global_id("Ship", "9"),
-        },
-        "faction" => {"name" => STAR_WARS_DATA["Faction"]["1"].name }
-      }
-    }}
-    assert_equal(expected, result)
+    new_ship_name = result["data"]["introduceShip"]["shipEdge"]["node"]["name"]
+    assert_equal("Bagel", new_ship_name)
   end
 end

data/spec/graphql/schema/reduce_types_spec.rb

@@ -14,6 +14,7 @@ describe GraphQL::Schema::ReduceTypes do
       "Int" => GraphQL::INT_TYPE,
       "Edible" => EdibleInterface,
       "AnimalProduct" => AnimalProductInterface,
+      "LocalProduct" => LocalProductInterface,
     }
     result = reduce_types([CheeseType])
     assert_equal(expected.keys, result.keys)

data/spec/graphql/union_type_spec.rb

@@ -12,11 +12,11 @@ describe GraphQL::UnionType do
       possible_types(types)
     }
   }
+
   it "has a name" do
     assert_equal("MyUnion", union.name)
   end
 
-
   it "infers type from an object" do
     assert_equal(CheeseType, DairyProductUnion.resolve_type(CHEESES[1], OpenStruct.new(schema: DummySchema)))
   end
@@ -29,6 +29,33 @@ describe GraphQL::UnionType do
     assert_equal(false, union.include?(type_3))
   end
 
+  describe "typecasting from union to union" do
+    let(:result) { DummySchema.execute(query_string) }
+    let(:query_string) {%|
+      {
+        allDairy {
+          dairyName: __typename
+          ... on Beverage {
+            bevName: __typename
+            ... on Milk {
+              flavors
+            }
+          }
+        }
+      }
+    |}
+
+    it "casts if the object belongs to both unions" do
+      expected_result = [
+        {"dairyName"=>"Cheese"},
+        {"dairyName"=>"Cheese"},
+        {"dairyName"=>"Cheese"},
+        {"dairyName"=>"Milk", "bevName"=>"Milk", "flavors"=>["Natural", "Chocolate", "Strawberry"]},
+      ]
+      assert_equal expected_result, result["data"]["allDairy"]
+    end
+  end
+
   describe "list of union type" do
     describe "fragment spreads" do
       let(:result) { DummySchema.execute(query_string) }

data/spec/support/dairy_app.rb

@@ -5,6 +5,17 @@ class NoSuchDairyError < StandardError; end
 GraphQL::Field.accepts_definitions(joins: GraphQL::Define.assign_metadata_key(:joins))
 GraphQL::BaseType.accepts_definitions(class_names: GraphQL::Define.assign_metadata_key(:class_names))
 
+LocalProductInterface = GraphQL::InterfaceType.define do
+  name "LocalProduct"
+  description "Something that comes from somewhere"
+  field :origin, !types.String, "Place the thing comes from"
+  # This is a "bug" in the dummy app:
+  # it should actually check the incoming object to determine the type.
+  # But this is here so we can check _where_ misbehaving resolve_type
+  # functions wreak their havoc.
+  resolve_type -> (o, c) { MilkType }
+end
+
 EdibleInterface = GraphQL::InterfaceType.define do
   name "Edible"
   description "Something you can eat, yum"
@@ -18,6 +29,12 @@ AnimalProductInterface = GraphQL::InterfaceType.define do
   field :source, !types.String, "Animal which produced this product"
 end
 
+BeverageUnion = GraphQL::UnionType.define do
+  name "Beverage"
+  description "Something you can drink"
+  possible_types [MilkType]
+end
+
 DairyAnimalEnum = GraphQL::EnumType.define do
   name "DairyAnimal"
   description "An animal which can yield milk"
@@ -31,7 +48,7 @@ CheeseType = GraphQL::ObjectType.define do
   name "Cheese"
   class_names ["Cheese"]
   description "Cultured dairy product"
-  interfaces [EdibleInterface, AnimalProductInterface]
+  interfaces [EdibleInterface, AnimalProductInterface, LocalProductInterface]
 
   # Can have (name, type, desc)
   field :id, !types.Int, "Unique identifier"
@@ -78,7 +95,7 @@ end
 MilkType = GraphQL::ObjectType.define do
   name "Milk"
   description "Dairy beverage"
-  interfaces [EdibleInterface, AnimalProductInterface]
+  interfaces [EdibleInterface, 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"
@@ -254,6 +271,10 @@ DairyAppQueryType = GraphQL::ObjectType.define do
     resolve -> (obj, args, ctx) { CHEESES.values + MILKS.values }
   end
 
+  field :allEdible, types[EdibleInterface] do
+    resolve -> (obj, args, ctx) { CHEESES.values + MILKS.values }
+  end
+
   field :error do
     description "Raise an error"
     type GraphQL::STRING_TYPE
@@ -317,6 +338,6 @@ DummySchema = GraphQL::Schema.new(
   mutation: DairyAppMutationType,
   subscription: SubscriptionType,
   max_depth: 5,
-  types: [HoneyType],
+  types: [HoneyType, BeverageUnion],
 )
 DummySchema.rescue_from(NoSuchDairyError) { |err| err.message  }

data/spec/support/star_wars_schema.rb

@@ -177,7 +177,7 @@ IntroduceShipMutation = GraphQL::Relay::Mutation.define do
   input_field :factionId, !types.ID
 
   # Result may have access to these fields:
-  return_field :ship, Ship
+  return_field :shipEdge, Ship.edge_type
   return_field :faction, Faction
 
   # Here's the mutation operation:
@@ -185,7 +185,10 @@ IntroduceShipMutation = GraphQL::Relay::Mutation.define do
     faction_id = inputs["factionId"]
     ship = STAR_WARS_DATA.create_ship(inputs["shipName"], faction_id)
     faction = STAR_WARS_DATA["Faction"][faction_id]
-    { ship: ship, faction: faction }
+    connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(faction.ships)
+    ships_connection = connection_class.new(faction.ships, inputs)
+    ship_edge = GraphQL::Relay::Edge.new(ship, ships_connection)
+    { shipEdge: ship_edge, faction: faction }
   }
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 0.18.2
+  version: 0.18.3
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-17 00:00:00.000000000 Z
+date: 2016-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codeclimate-test-reporter
@@ -346,7 +346,6 @@ files:
 - lib/graphql/schema.rb
 - lib/graphql/schema/catchall_middleware.rb
 - lib/graphql/schema/invalid_type_error.rb
-- lib/graphql/schema/middleware.rb
 - lib/graphql/schema/middleware_chain.rb
 - lib/graphql/schema/possible_types.rb
 - lib/graphql/schema/printer.rb
@@ -397,6 +396,7 @@ files:
 - spec/graphql/define/instance_definable_spec.rb
 - spec/graphql/directive_spec.rb
 - spec/graphql/enum_type_spec.rb
+- spec/graphql/execution/typecast_spec.rb
 - spec/graphql/execution_error_spec.rb
 - spec/graphql/field_spec.rb
 - spec/graphql/float_type_spec.rb
@@ -502,6 +502,7 @@ test_files:
 - spec/graphql/define/instance_definable_spec.rb
 - spec/graphql/directive_spec.rb
 - spec/graphql/enum_type_spec.rb
+- spec/graphql/execution/typecast_spec.rb
 - spec/graphql/execution_error_spec.rb
 - spec/graphql/field_spec.rb
 - spec/graphql/float_type_spec.rb

data/lib/graphql/schema/middleware.rb

@@ -1,75 +0,0 @@
-module GraphQL
-  class Schema
-    # - query_initialize
-    # - query_finalize
-    # - field_resolve
-    #
-    # @example Closing a socket when the query is finished
-    #   SocketClosingMiddleware = GraphQL::Schema::Middleware.define do
-    #     finalize_query -> (memo, env) {
-    #       query.context[:socket].close
-    #     }
-    #   end
-    #
-    # @example Timing a query
-    #   QueryTimerMiddleware = GraphQL::Schema::Middleware.define do
-    #     initialize_query -> (env) {
-    #       env.merge!({
-    #         query_start_time: Time.now,
-    #         field_times: [],
-    #       })
-    #     }
-    #
-    #     resolve_field -> (env) {
-    #       field_time = {
-    #         start_time: Time.now,
-    #         own_elapsed: nil,
-    #         child_elapsed: 0,
-    #       }
-    #
-    #       memo[:field_times] << field_time
-    #       memo
-    #     }
-    #
-    #     after_field { |memo, env|
-    #       field_time = memo[:field_times].pop
-    #       total_elapsed = Time.now - field_time[:start_time]
-    #       own_elapsed = total_elapsed - field_time[:child_elapsed]
-    #
-    #       field_name = "#{env[:parent_type].name}.#{env[:field_definition].name}(#{env[:arguments].to_h.to_json})"
-    #       Logger.info("[GraphQL Field] #{field_name} #{own_elapsed}")
-    #
-    #       parent_field_time = memo[:field_times].last
-    #       if parent_field_time
-    #         parent_field_time[:child_elapsed] += total_elapsed
-    #       end
-    #     }
-    #
-    #     after_query { |memo, env|
-    #       elapsed = Time.now - memo[:query_start_time]
-    #       Logger.info("[GraphQL Elapsed] #{elapsed}")
-    #     }
-    #   end
-    class Middleware
-      EVENTS = [:before_query, :after_query, :before_field, :after_field]
-      class << self
-        attr_reader :handlers
-        def handlers
-          @handlers ||= {}
-        end
-
-        def on(event_name, &handler)
-          if EVENTS.include?(event_name)
-            handlers[event_name] = handler
-          else
-            raise("Can't attach handler to #{event_name} (must be one of: #{EVENTS})")
-          end
-        end
-      end
-
-      def trigger(event_name, *args)
-        self.class.handlers[event_name].call(*args)
-      end
-    end
-  end
-end