graphql 0.9.5 → 0.10.0

data/lib/graphql/static_validation/rules/variable_default_values_are_correctly_typed.rb

@@ -15,7 +15,7 @@ class GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped
     if node.type.is_a?(GraphQL::Language::Nodes::NonNullType)
       context.errors << message("Non-null variable $#{node.name} can't have a default value", node)
     else
-      type = context.schema.types[node.type.name]
+      type = context.schema.type_from_ast(node.type)
       if !literal_validator.validate(value, type)
         context.errors << message("Default value for $#{node.name} doesn't match type #{node.type.name}", node)
       end

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.9.5"
+  VERSION = "0.10.0"
 end

data/readme.md

@@ -94,7 +94,7 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
 - Code clean-up
   - Raise if you try to configure an attribute which doesn't suit the type
     - ie, if you try to define `resolve` on an ObjectType, it should somehow raise
-  - Incoming enums should be exposed as `EnumValue`s, not `Nodes::Enum`s
+  - Clean up file structure in `lib/query` (don't need serial_execution namespace anymore)
   - Overriding `!` on types breaks ActiveSupport `.blank?`
 
     ```ruby
@@ -105,9 +105,10 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
     my_type.blank?
     # => MyType!
     ```
-
+- Statically validate type of variables (see early return in LiteralValidator)
 - Big ideas:
   - Use [graphql-parser](https://github.com/shopify/graphql-parser) (Ruby bindings for [libgraphqlparser](https://github.com/graphql/libgraphqlparser)) instead of Parslet
+  - Revamp the fixture Schema to be more useful (better names, more extensible)
 
 ## Goals
 

data/spec/graphql/enum_type_spec.rb

@@ -4,7 +4,12 @@ describe GraphQL::EnumType do
   let(:enum) { DairyAnimalEnum }
 
   it 'coerces names to underlying values' do
-    assert_equal("YAK", enum.coerce("YAK"))
-    assert_equal(1, enum.coerce("COW"))
+    assert_equal("YAK", enum.coerce_input("YAK"))
+    assert_equal(1, enum.coerce_input("COW"))
+  end
+
+  it 'coerces result values to value name' do
+    assert_equal("YAK", enum.coerce_result("YAK"))
+    assert_equal("COW", enum.coerce_result(1))
   end
 end

data/spec/graphql/input_object_type_spec.rb

@@ -9,4 +9,49 @@ describe GraphQL::InputObjectType do
   it 'has input fields' do
     assert(DairyProductInputType.input_fields["fatContent"])
   end
+
+  describe "when sent into a query" do
+    let(:variables) { {} }
+    let(:result) { DummySchema.execute(query_string, variables: variables) }
+
+    describe "list inputs" do
+      let(:variables) { {"search" => [{"source" => "COW"}]} }
+      let(:query_string) {%|
+        query getCheeses($search: [DairyProductInput]!){
+            sheep: searchDairy(product: [{source: SHEEP, fatContent: 0.1}]) {
+              ... cheeseFields
+            }
+            cow: searchDairy(product: $search) {
+              ... cheeseFields
+            }
+        }
+
+        fragment cheeseFields on Cheese {
+          flavor
+        }
+      |}
+
+      it "converts items to plain values" do
+        sheep_value = result["data"]["sheep"]["flavor"]
+        cow_value = result["data"]["cow"]["flavor"]
+        assert_equal("Manchego", sheep_value)
+        assert_equal("Brie", cow_value)
+      end
+    end
+
+    describe "scalar inputs" do
+      let(:query_string) {%|
+        {
+          cheese(id: 1.4) {
+            flavor
+          }
+        }
+      |}
+
+      it "converts them to the correct type" do
+        cheese_name = result["data"]["cheese"]["flavor"]
+        assert_equal("Brie", cheese_name)
+      end
+    end
+  end
 end

data/spec/graphql/language/parser_spec.rb

@@ -42,7 +42,8 @@ describe GraphQL::Language::Parser 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(%|mutation changeStuff($stuff: Int = 1, $things: [SomeType]!) {id, name, ...people}|), "mutation with arguments")
+    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
 
   it 'parses fragment definitions' do

data/spec/graphql/language/transform_spec.rb

@@ -118,4 +118,9 @@ describe GraphQL::Language::Transform do
     assert_equal("someFlag", res.name)
     assert_equal([], res.arguments, 'gets [] if no args')
   end
+
+  it 'transforms unnamed operations' do
+    assert_equal(1, get_result("query { me }").parts.length)
+    assert_equal(1, get_result("mutation { touch }").parts.length)
+  end
 end

data/spec/graphql/query/base_execution/value_resolution_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe GraphQL::Query::BaseExecution::ValueResolution do
+  let(:debug) { false }
+  let(:query_root) {
+    day_of_week_enum = GraphQL::EnumType.define do
+      name "DayOfWeek"
+      value("MONDAY", value: 0)
+      value("TUESDAY", value: 1)
+      value("WEDNESDAY", value: 2)
+      value("THURSDAY", value: 3)
+      value("FRIDAY", value: 4)
+      value("SATURDAY", value: 5)
+      value("SUNDAY", value: 6)
+    end
+    GraphQL::ObjectType.define do
+      name "Query"
+      field :tomorrow, day_of_week_enum do
+        argument :today, day_of_week_enum
+        resolve ->(obj, args, ctx) { (args['today'] + 1) % 7 }
+      end
+    end
+  }
+  let(:schema) { GraphQL::Schema.new(query: query_root) }
+  let(:result) { schema.execute(
+    query_string,
+    debug: debug,
+  )}
+
+  describe "enum resolution" do
+    let(:query_string) { %|
+      {
+        tomorrow(today: FRIDAY)
+      }
+    |}
+
+    it "coerces enum input to the value and result to the name" do
+      expected = {
+        "data" => {
+          "tomorrow" => "SATURDAY"
+        }
+      }
+      assert_equal(expected, result)
+    end
+  end
+end

data/spec/graphql/query/context_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe GraphQL::Query::Context do
+  let(:query_type) { GraphQL::ObjectType.define {
+    field :context, types.String do
+      argument :key, !types.String
+      resolve -> (target, args, ctx) { ctx[args[:key]] }
+    end
+    field :contextAstNodeName, types.String do
+      resolve -> (target, args, ctx) { ctx.ast_node.class.name }
+    end
+  }}
+  let(:schema) { GraphQL::Schema.new(query: query_type, mutation: nil)}
+  let(:result) { schema.execute(query_string, context: {"some_key" => "some value"})}
+
+  describe "access to passed-in values" do
+    let(:query_string) { %|
+      query getCtx { context(key: "some_key") }
+    |}
+
+    it 'passes context to fields' do
+      expected = {"data" => {"context" => "some value"}}
+      assert_equal(expected, result)
+    end
+  end
+
+  describe "access to the AST node" do
+    let(:query_string) { %|
+      query getCtx { contextAstNodeName }
+    |}
+
+    it 'provides access to the AST node' do
+      expected = {"data" => {"contextAstNodeName" => "GraphQL::Language::Nodes::Field"}}
+      assert_equal(expected, result)
+    end
+  end
+end

data/spec/graphql/query/executor_spec.rb

@@ -154,7 +154,40 @@ describe GraphQL::Query::Executor do
         }
         assert_equal(expected, result)
       end
+    end
+  end
+
+  describe "variable coercion" do
+    describe "for unspecified with default" do
+      let(:query_string) {%| query Q($limit: Int = 2) { milk(id: 1) { flavors(limit: $limit) } } |}
 
+      it "uses the default value" do
+        expected = {
+          "data" => {
+            "milk" => {
+              "flavors" => ["Natural", "Chocolate"],
+            }
+          }
+        }
+        assert_equal(expected, result)
+      end
+    end
+
+    describe "for input object type" do
+      let(:variables) { {"input" => [{ "source" => "SHEEP" }]} }
+      let(:query_string) {%| query Q($input: [DairyProductInput]) { searchDairy(product: $input) { __typename, ... on Cheese { id, source } } } |}
+      it "uses the default value" do
+        expected = {
+          "data" => {
+            "searchDairy" => {
+              "__typename" => "Cheese",
+              "id" => 3,
+              "source" => "SHEEP"
+            }
+          }
+        }
+        assert_equal(expected, result)
+      end
     end
   end
 end

data/spec/graphql/query_spec.rb

@@ -13,7 +13,7 @@ describe GraphQL::Query do
       }
       fromSource(source: COW) { id }
       fromSheep: fromSource(source: SHEEP) { id }
-      firstSheep: searchDairy(product: {source: SHEEP}) {
+      firstSheep: searchDairy(product: [{source: SHEEP}]) {
         __typename,
         ... dairyFields,
         ... milkFields
@@ -30,10 +30,12 @@ describe GraphQL::Query do
   |}
   let(:debug) { false }
   let(:operation_name) { nil }
+  let(:query_variables) { {"cheeseId" => 2} }
+  let(:schema) { DummySchema }
   let(:query) { GraphQL::Query.new(
-    DummySchema,
+    schema,
     query_string,
-    variables: {"cheeseId" => 2},
+    variables: query_variables,
     debug: debug,
     operation_name: operation_name,
   )}
@@ -159,38 +161,120 @@ describe GraphQL::Query do
     end
   end
 
-  describe 'context' do
-    let(:query_type) { GraphQL::ObjectType.define {
-      field :context, types.String do
-        argument :key, !types.String
-        resolve -> (target, args, ctx) { ctx[args[:key]] }
+  describe "field argument default values" do
+    let(:query_string) {%|
+      query getCheeses(
+        $search: [DairyProductInput]
+        $searchWithDefault: [DairyProductInput] = [{source: COW}]
+      ){
+        noVariable: searchDairy(product: $search) {
+          ... cheeseFields
+        }
+        noArgument: searchDairy {
+          ... cheeseFields
+        }
+        variableDefault: searchDairy(product: $searchWithDefault) {
+          ... cheeseFields
+        }
+
+      }
+      fragment cheeseFields on Cheese { flavor }
+    |}
+
+    it "has a default value" do
+      default_source = schema.query.fields["searchDairy"].arguments["product"].default_value[0]["source"]
+      assert_equal("SHEEP", default_source)
+    end
+
+    describe "when a variable is used, but not provided" do
+      it "uses the default_value" do
+        assert_equal("Manchego", result["data"]["noVariable"]["flavor"])
       end
-      field :contextAstNodeName, types.String do
-        resolve -> (target, args, ctx) { ctx.ast_node.class.name }
+    end
+
+    describe "when the argument isn't passed at all" do
+      it "uses the default value" do
+        assert_equal("Manchego", result["data"]["noArgument"]["flavor"])
       end
-    }}
-    let(:schema) { GraphQL::Schema.new(query: query_type, mutation: nil)}
-    let(:query) { GraphQL::Query.new(schema, query_string, context: {"some_key" => "some value"})}
+    end
 
-    describe "access to passed-in values" do
-      let(:query_string) { %|
-        query getCtx { context(key: "some_key") }
-      |}
+    describe "when the variable has a default" do
+      it "uses the variable default" do
+        assert_equal("Brie", result["data"]["variableDefault"]["flavor"])
+      end
+    end
+  end
+
+  describe "query variables" do
+    let(:query_string) {%|
+      query getCheese($cheeseId: Int!){
+        cheese(id: $cheeseId) { flavor }
+      }
+    |}
 
-      it 'passes context to fields' do
-        expected = {"data" => {"context" => "some value"}}
-        assert_equal(expected, query.result)
+    describe "when they can be coerced" do
+      let(:query_variables) { {"cheeseId" => 2.0} }
+
+      it "coerces them on the way in" do
+        assert("Gouda", result["data"]["cheese"]["flavor"])
+      end
+    end
+
+    describe "when they can't be coerced" do
+      let(:query_variables) { {"cheeseId" => "2"} }
+
+      it "raises an error" do
+        assert(result["errors"][0]["message"].include?(%{Couldn't coerce "2" to Int}))
       end
     end
 
-    describe "access to the AST node" do
-      let(:query_string) { %|
-        query getCtx { contextAstNodeName }
+    describe "when they aren't provided" do
+      let(:query_variables) { {} }
+
+      it "raises an error" do
+        expected = "Variable cheeseId of type Int! can't be null"
+        assert_equal(result["errors"][0]["message"], expected)
+      end
+    end
+
+    describe "default values" do
+      let(:query_string) {%|
+        query getCheese($cheeseId: Int = 3){
+          cheese(id: $cheeseId) { id, flavor }
+        }
       |}
 
-      it 'provides access to the AST node' do
-        expected = {"data" => {"contextAstNodeName" => "GraphQL::Language::Nodes::Field"}}
-        assert_equal(expected, query.result)
+      describe "when no value is provided" do
+        let(:query_variables) { {} }
+
+        it "uses the default" do
+          assert(3, result["data"]["cheese"]["id"])
+          assert("Manchego", result["data"]["cheese"]["flavor"])
+        end
+      end
+
+      describe "when a value is provided" do
+        it "uses the provided variable" do
+          assert(2, result["data"]["cheese"]["id"])
+          assert("Gouda", result["data"]["cheese"]["flavor"])
+        end
+      end
+
+      describe "when complex values" do
+        let(:query_variables) { {"search" => [{"source" => "COW"}]} }
+        let(:query_string) {%|
+          query getCheeses($search: [DairyProductInput]!){
+            cow: searchDairy(product: $search) {
+              ... on Cheese {
+                flavor
+              }
+            }
+          }
+        |}
+
+        it "coerces recursively" do
+          assert_equal("Brie", result["data"]["cow"]["flavor"])
+        end
       end
     end
   end

data/spec/graphql/schema/type_expression_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe GraphQL::Schema::TypeExpression do
+  let(:schema) { DummySchema }
+  let(:ast_node) {
+    ast = GraphQL::PARSER.type.parse(type_name)
+    GraphQL::TRANSFORM.apply(ast)
+  }
+  let(:type_expression) { GraphQL::Schema::TypeExpression.new(schema, ast_node) }
+
+  describe "#type" do
+    describe "simple types" do
+      let(:type_name) { "DairyProductInput" }
+      it "it gets types from the schema" do
+        assert_equal(DairyProductInputType, type_expression.type)
+      end
+    end
+
+    describe "non-null types" do
+      let(:type_name) { "String!"}
+      it "makes non-null types" do
+        assert_equal(GraphQL::STRING_TYPE.to_non_null_type, type_expression.type)
+      end
+    end
+
+    describe "list types" do
+      let(:type_name) { "[DairyAnimal!]!" }
+
+      it "makes list types" do
+        expected = DairyAnimalEnum
+          .to_non_null_type
+          .to_list_type
+          .to_non_null_type
+        assert_equal(expected, type_expression.type)
+      end
+    end
+  end
+end