graphql 0.10.2 → 0.10.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a8c997dbb80987c2b0312c95913b8cb7bef898be
-  data.tar.gz: f77f1a3b90d96887a93ee560f8dd5ba5370a4453
+  metadata.gz: cace79bd801a58fbf53eb0ff5a5ef4ea501b1208
+  data.tar.gz: 495b61e0510a41d880db3a99008446650196742a
 SHA512:
-  metadata.gz: 4f20614f4bcefc6ed7771c516046ae24581785ea25579e0bd5a8bdcad1cbd7d5eca7c981e59b4eec08bb54772cdb15c3f5f44f62eee1ea51d224e2c87608c821
-  data.tar.gz: a525157abbc09c4b1abd6e55a18b975305dbb93d8583709850bc159cb2e7d87ee62dd3b3d7fddf9188daa3e6c07f1bb83f2c8715c921c8b12b1e898e823dfbf0
+  metadata.gz: 635f9a6cbc5d9093227b3699cb93271526c105fff445bacc4e1a39777a51a6b8db1fcc5c692271a0de4d00045b2dd3d33b39dfea90f33c74176ef6ea3e7a57cb
+  data.tar.gz: 8ca5879203ad6178ad7fff7e3ef12e76de2c90825b1de2e5efd831afe654f49bb3d02b0f9ef6a5d5654586ee20693452ba971e645717d2e561caba396c6c1e3d

data/lib/graphql.rb

@@ -1,5 +1,6 @@
 require "json"
 require "parslet"
+require "set"
 require "singleton"
 require "forwardable"
 

data/lib/graphql/introspection/introspection_query.rb

@@ -5,6 +5,7 @@ query IntrospectionQuery {
   __schema {
     queryType { name }
     mutationType { name }
+    subscriptionType { name }
     types {
       ...FullType
     }
@@ -24,7 +25,7 @@ fragment FullType on __Type {
   kind
   name
   description
-  fields {
+  fields(includeDeprecated: true) {
     name
     description
     args {
@@ -42,7 +43,7 @@ fragment FullType on __Type {
   interfaces {
     ...TypeRef
   }
-  enumValues {
+  enumValues(includeDeprecated: true) {
     name
     description
     isDeprecated

data/lib/graphql/introspection/schema_type.rb

@@ -17,4 +17,8 @@ GraphQL::Introspection::SchemaType = GraphQL::ObjectType.define do
   field :mutationType, GraphQL::Introspection::TypeType, "The mutation root of this schema" do
     resolve -> (obj, arg, ctx) { obj.mutation }
   end
+
+  field :subscriptionType, GraphQL::Introspection::TypeType, "The subscription root of this schema" do
+    resolve -> (obj, arg, ctx) { obj.subscription }
+  end
 end

data/lib/graphql/language/parser.rb

@@ -43,7 +43,7 @@ module GraphQL
         directives.maybe.as(:optional_directives).as(:directives) >> space? >>
         selections.as(:selections)
       }
-      rule(:operation_type) { (str("query") | str("mutation")) }
+      rule(:operation_type) { (str("query") | str("mutation") | str("subscription")) }
       rule(:operation_variable_definitions) { str("(") >> space? >> (operation_variable_definition >> separator?).repeat(1) >> space? >> str(")") }
       rule(:operation_variable_definition) {
         value_variable.as(:variable_name) >> space? >>

data/lib/graphql/query/executor.rb

@@ -29,14 +29,11 @@ module GraphQL
         operation = query.selected_operation
         return {} if operation.nil?
 
-        if operation.operation_type == "query"
-          root_type = query.schema.query
-          execution_strategy_class = query.schema.query_execution_strategy
-        elsif operation.operation_type == "mutation"
-          root_type = query.schema.mutation
-          execution_strategy_class = query.schema.mutation_execution_strategy
-        end
+        op_type = operation.operation_type
+        root_type = query.schema.public_send(op_type)
+        execution_strategy_class = query.schema.public_send("#{op_type}_execution_strategy")
         execution_strategy = execution_strategy_class.new
+
         query.context.execution_strategy = execution_strategy
         data_result = execution_strategy.execute(operation, root_type, query)
         result = { "data" => data_result }

data/lib/graphql/schema.rb

@@ -5,18 +5,22 @@ class GraphQL::Schema
   DIRECTIVES = [GraphQL::Directive::SkipDirective, GraphQL::Directive::IncludeDirective]
   DYNAMIC_FIELDS = ["__type", "__typename", "__schema"]
 
-  attr_reader :query, :mutation, :directives, :static_validator
+  attr_reader :query, :mutation, :subscription, :directives, :static_validator
   # Override these if you don't want the default executor:
-  attr_accessor :query_execution_strategy, :mutation_execution_strategy
+  attr_accessor :query_execution_strategy,
+    :mutation_execution_strategy,
+    :subscription_execution_strategy
 
   # @return [Array<#call>] Middlewares suitable for MiddlewareChain, applied to fields during execution
   attr_reader :middleware
 
   # @param query [GraphQL::ObjectType]  the query root for the schema
-  # @param mutation [GraphQL::ObjectType, nil] the mutation root for the schema
-  def initialize(query:, mutation: nil)
+  # @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)
     @query    = query
     @mutation = mutation
+    @subscription = subscription
     @directives = DIRECTIVES.reduce({}) { |m, d| m[d.name] = d; m }
     @static_validator = GraphQL::StaticValidation::Validator.new(schema: self)
     @rescue_middleware = GraphQL::Schema::RescueMiddleware.new
@@ -24,6 +28,7 @@ class GraphQL::Schema
     # Default to the built-in execution strategy:
     self.query_execution_strategy = GraphQL::Query::SerialExecution
     self.mutation_execution_strategy = GraphQL::Query::SerialExecution
+    self.subscription_execution_strategy = GraphQL::Query::SerialExecution
   end
 
   def_delegators :@rescue_middleware, :rescue_from, :remove_handler

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.10.2"
+  VERSION = "0.10.3"
 end

data/spec/graphql/language/parser_spec.rb

@@ -22,6 +22,9 @@ describe GraphQL::Language::Parser do
         ... family # background info, of course
       }
     }
+    subscription watchStuff {
+      field, otherField
+    }
 
     # a fragment:
     fragment family on Species {
@@ -41,7 +44,7 @@ describe GraphQL::Language::Parser do
   it 'parses operation definitions' do
     assert(parser.operation_definition.parse_with_debug(%|{id, name, ...people}|), "just a selection")
     assert(parser.operation_definition.parse_with_debug(%|query personStuff {id, name, ...people, ... stuff}|), "named fetch")
-    assert(parser.operation_definition.parse_with_debug(%|query personStuff @flagDirective {id, name, ...people}|), "with a directive")
+    assert(parser.operation_definition.parse_with_debug(%|subscription personStuff @flagDirective {id, name, ...people}|), "with a directive")
     assert(parser.operation_definition.parse_with_debug(%|mutation changeStuff($stuff: Int = 1 $things: [SomeType]! = [{something: 1}, {something: 2}], $another: Sometype = {something: 3}) { id }|), "mutation with arguments")
     assert(parser.operation_definition.parse_with_debug(%|mutation { id }|), "unnamed")
   end

data/spec/graphql/schema/printer_spec.rb

@@ -103,6 +103,7 @@ type __Schema {
   directives: [__Directive!]!
   queryType: __Type!
   mutationType: __Type
+  subscriptionType: __Type
 }
 
 type __Type {

data/spec/graphql/schema_spec.rb

@@ -13,4 +13,11 @@ describe GraphQL::Schema do
       assert_equal(2, rescue_middleware.rescue_table.length)
     end
   end
+
+  describe "#subscription" do
+    it "calls fields on the subscription type" do
+      res = schema.execute("subscription { test }")
+      assert_equal("Test", res["data"]["test"])
+    end
+  end
 end

data/spec/support/calculator_schema.rb

@@ -1,73 +1,74 @@
 # 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,
+  }
 
-# 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)
+  ReducerEnum = GraphQL::EnumType.define do
+    REDUCERS.map do |op_name, op_proc|
+      value(op_name)
+    end
   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},
-}
+  # 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)
+  MapperEnum = GraphQL::EnumType.define do
+    MAPPERS.map do |op_name, op_proc|
+      value(op_name)
+    end
   end
-end
 
-# Input a list of integers
-ListOfInts = GraphQL::INT_TYPE.to_list_type
+  # 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
+  # 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
+    # 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) }
-    }
+    # 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
-end
 
-QueryType = GraphQL::ObjectType.define do
-  name("Query")
+  QueryType = GraphQL::ObjectType.define do
+    name("Query")
 
-  field :perform, ValuesType do
-    argument :initial, !ListOfInts
-    resolve -> (obj, args, ctx) { args[:initial] }
+    field :perform, ValuesType do
+      argument :initial, !ListOfInts
+      resolve -> (obj, args, ctx) { args[:initial] }
+    end
   end
-end
 
-CalculatorSchema = GraphQL::Schema.new(query: QueryType)
+  Schema = GraphQL::Schema.new(query: QueryType)
+end

data/spec/support/dairy_app.rb

@@ -219,5 +219,16 @@ MutationType = GraphQL::ObjectType.define do
   end
 end
 
-DummySchema = GraphQL::Schema.new(query: QueryType, mutation: MutationType)
+SubscriptionType = GraphQL::ObjectType.define do
+  name "Subscription"
+  field :test, types.String do
+    resolve -> (o, a, c) { "Test" }
+  end
+end
+
+DummySchema = GraphQL::Schema.new(
+  query: QueryType,
+  mutation: MutationType,
+  subscription: SubscriptionType,
+)
 DummySchema.rescue_from(NoSuchDairyError) { |err| err.message  }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 0.10.2
+  version: 0.10.3
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-10 00:00:00.000000000 Z
+date: 2015-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet