graphql 0.18.5 → 0.18.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9d69978a50350e058883fa1f9fdfc5c6e5dcc80b
-  data.tar.gz: 97cc2fdfc3778f6b75cf34a2b9d5dcf6354a1a28
+  metadata.gz: 097a1f2ab62a05d6617d2445c0771066c1d547a3
+  data.tar.gz: c65cc3378d3a1e525881abfde3c520b2f2eac71a
 SHA512:
-  metadata.gz: c6177a5c17291fc6f95f0f2d8e14f3831ebc9af7f46addd15bc3283a63310151c8fc7fbfc1acc332a181ab808060afb399fd87ce83db6e0088c093adabd8b35b
-  data.tar.gz: b0464b86095e2aafa933d4dc5b6e5491ef2354df6025943967a78d36d63d7f7c2111e6bfaefe3b11abd5d8937c1ba14e160b5fe9d255cc7b5501d56b0f8e92a1
+  metadata.gz: 913f57d14573f3fef716bd604e1dc62827d1fb62361bde854e42fe32f357a3e88ee382f1f1605a1bb11a16fcc80f2a9e7ff5e223a408c83bf5b224b8e9d76913
+  data.tar.gz: cfd8abc3faad374f484e97ef7b3505486c60067fefb6c1295f3eb55f0478f750dd344c3da9a876c87179a8f3772597245a05e561430df4a4c4f685f055e17a4b

data/lib/graphql.rb

@@ -58,6 +58,7 @@ require "graphql/introspection"
 require "graphql/language"
 require "graphql/analysis"
 require "graphql/schema"
+require "graphql/schema/loader"
 require "graphql/schema/printer"
 
 # Order does not matter for these:

data/lib/graphql/argument.rb

@@ -26,5 +26,19 @@ module GraphQL
     end
 
     attr_writer :name
+
+    def type=(new_return_type)
+      ensure_defined
+      @clean_type = nil
+      @dirty_type = new_return_type
+    end
+
+    # Get the return type for this field.
+    def type
+      @clean_type ||= begin
+        ensure_defined
+        GraphQL::BaseType.resolve_related_type(@dirty_type)
+      end
+    end
   end
 end

data/lib/graphql/enum_type.rb

@@ -56,7 +56,7 @@ module GraphQL
   #   }
   #
   class EnumType < GraphQL::BaseType
-    accepts_definitions value: GraphQL::Define::AssignEnumValue
+    accepts_definitions :values, value: GraphQL::Define::AssignEnumValue
 
     def initialize
       @values_by_name = {}
@@ -124,6 +124,10 @@ module GraphQL
     #
     # Created with the `value` helper
     class EnumValue
+      def self.define(name:, description: nil, deprecation_reason: nil, value: nil)
+        new(name: name, description: description, deprecation_reason: deprecation_reason, value: value)
+      end
+
       attr_accessor :name, :description, :deprecation_reason, :value
       def initialize(name:, description:, deprecation_reason:, value:)
         @name = name

data/lib/graphql/field.rb

@@ -120,7 +120,7 @@ module GraphQL
   #
   class Field
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :name, :description, :resolve, :type, :property, :deprecation_reason, :complexity, :hash_key, argument: GraphQL::Define::AssignArgument
+    accepts_definitions :name, :description, :resolve, :type, :property, :deprecation_reason, :complexity, :hash_key, :arguments, argument: GraphQL::Define::AssignArgument
 
     lazy_defined_attr_accessor :deprecation_reason, :description, :property, :hash_key
 

data/lib/graphql/input_object_type.rb

@@ -24,6 +24,7 @@ module GraphQL
   #
   class InputObjectType < GraphQL::BaseType
     accepts_definitions(
+      :arguments,
       input_field: GraphQL::Define::AssignArgument,
       argument: GraphQL::Define::AssignArgument
     )

data/lib/graphql/interface_type.rb

@@ -23,7 +23,7 @@ module GraphQL
   #
   class InterfaceType < GraphQL::BaseType
     include GraphQL::BaseType::HasPossibleTypes
-    accepts_definitions :resolve_type, field: GraphQL::Define::AssignObjectField
+    accepts_definitions :resolve_type, :fields, field: GraphQL::Define::AssignObjectField
 
     lazy_defined_attr_accessor :fields
 

data/lib/graphql/language/parser_tests.rb

@@ -0,0 +1,577 @@
+module GraphQL
+  module Language
+    # If you create your own GraphQL parser, can verify it using these tests.
+    #
+    # @example Include these tests in a Minitest suite
+    #   require 'graphql/language/parser_tests'
+    #
+    #   describe MyParser do
+    #     include GraphQL::Language::ParserTests
+    #     subject { MyParser }
+    #   end
+    module ParserTests
+      def self.included(test)
+        test.send(:describe, "Parser Tests") do
+          let(:document) { subject.parse(query_string) }
+          let(:query_string) {%|
+            query getStuff($someVar: Int = 1, $anotherVar: [String!] ) @skip(if: false) {
+              myField: someField(someArg: $someVar, ok: 1.4) @skip(if: $anotherVar) @thing(or: "Whatever")
+
+              anotherField(someArg: [1,2,3]) {
+                nestedField
+                ... moreNestedFields @skip(if: true)
+              }
+
+              ... on OtherType @include(unless: false){
+                field(arg: [{key: "value", anotherKey: 0.9, anotherAnotherKey: WHATEVER}])
+                anotherField
+              }
+
+              ... {
+                id
+              }
+            }
+
+            fragment moreNestedFields on NestedType @or(something: "ok") {
+              anotherNestedField
+            }
+          |}
+
+          describe ".parse" do
+            it "parses queries" do
+              assert document
+            end
+
+            describe "visited nodes" do
+              let(:query) { document.definitions.first }
+              let(:fragment_def) { document.definitions.last }
+
+              it "creates a valid document" do
+                assert document.is_a?(GraphQL::Language::Nodes::Document)
+                assert_equal 2, document.definitions.length
+              end
+
+              it "creates a valid operation" do
+                assert query.is_a?(GraphQL::Language::Nodes::OperationDefinition)
+                assert_equal "getStuff", query.name
+                assert_equal "query", query.operation_type
+                assert_equal 2, query.variables.length
+                assert_equal 4, query.selections.length
+                assert_equal 1, query.directives.length
+                assert_equal [2, 13], [query.line, query.col]
+              end
+
+              it "creates a valid fragment definition" do
+                assert fragment_def.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
+                assert_equal "moreNestedFields", fragment_def.name
+                assert_equal 1, fragment_def.selections.length
+                assert_equal "NestedType", fragment_def.type
+                assert_equal 1, fragment_def.directives.length
+                assert_equal [20, 13], fragment_def.position
+              end
+
+              describe "variable definitions" do
+                let(:optional_var) { query.variables.first }
+                it "gets name and type" do
+                  assert_equal "someVar", optional_var.name
+                  assert_equal "Int", optional_var.type.name
+                end
+
+                it "gets default value" do
+                  assert_equal 1, optional_var.default_value
+                end
+
+                it "gets position info" do
+                  assert_equal [2, 28], optional_var.position
+                end
+              end
+
+              describe "fields" do
+                let(:leaf_field) { query.selections.first }
+                let(:parent_field) { query.selections[1] }
+
+                it "gets name, alias, arguments and directives" do
+                  assert_equal "someField", leaf_field.name
+                  assert_equal "myField", leaf_field.alias
+                  assert_equal 2, leaf_field.directives.length
+                  assert_equal 2, leaf_field.arguments.length
+                end
+
+                it "gets nested fields" do
+                  assert_equal 2, parent_field.selections.length
+                end
+
+                it "gets location info" do
+                  assert_equal [3 ,15], leaf_field.position
+                end
+
+                describe "when the arguments list is empty" do
+                  let(:query_string) { "{ field() }"}
+                  let(:field) { query.selections.first }
+                  it "has zero arguments" do
+                    assert_equal 0, field.arguments.length
+                  end
+                end
+
+                describe "when selections are empty" do
+                  let(:query_string) { "{ field { } }"}
+                  let(:field) { query.selections.first }
+                  it "has zero selections" do
+                    assert_equal 0, field.selections.length
+                  end
+                end
+              end
+
+              describe "arguments" do
+                let(:literal_argument) { query.selections.first.arguments.last }
+                let(:variable_argument) { query.selections.first.arguments.first }
+
+                it "gets name and literal value" do
+                  assert_equal "ok", literal_argument.name
+                  assert_equal 1.4, literal_argument.value
+                end
+
+                it "gets name and variable value" do
+                  assert_equal "someArg", variable_argument.name
+                  assert_equal "someVar", variable_argument.value.name
+                end
+
+
+                it "gets position info" do
+                  assert_equal [3, 34], variable_argument.position
+                end
+              end
+
+              describe "fragment spreads" do
+                let(:fragment_spread) { query.selections[1].selections.last }
+                it "gets the name and directives" do
+                  assert_equal "moreNestedFields", fragment_spread.name
+                  assert_equal 1, fragment_spread.directives.length
+                end
+
+                it "gets position info" do
+                  assert_equal [7, 17], fragment_spread.position
+                end
+              end
+
+              describe "directives" do
+                let(:variable_directive) { query.selections.first.directives.first }
+
+                it "gets the name and arguments" do
+                  assert_equal "skip", variable_directive.name
+                  assert_equal "if", variable_directive.arguments.first.name
+                  assert_equal 1, variable_directive.arguments.length
+                end
+
+                it "gets position info" do
+                  assert_equal [3, 62], variable_directive.position
+                end
+              end
+
+              describe "inline fragments" do
+                let(:inline_fragment) { query.selections[2] }
+                let(:typeless_inline_fragment) { query.selections[3] }
+
+                it "gets the type and directives" do
+                  assert_equal "OtherType", inline_fragment.type
+                  assert_equal 2, inline_fragment.selections.length
+                  assert_equal 1, inline_fragment.directives.length
+                end
+
+                it "gets inline fragments without type conditions" do
+                  assert_equal nil, typeless_inline_fragment.type
+                  assert_equal 1, typeless_inline_fragment.selections.length
+                  assert_equal 0, typeless_inline_fragment.directives.length
+                end
+
+                it "gets position info" do
+                  assert_equal [10, 15], inline_fragment.position
+                end
+              end
+
+              describe "inputs" do
+                let(:query_string) {%|
+                  {
+                    field(
+                      int: 3,
+                      float: 4.7e-24,
+                      bool: false,
+                      string: "☀︎🏆\\n escaped \\" unicode \\u00b6 /",
+                      enum: ENUM_NAME,
+                      array: [7, 8, 9]
+                      object: {a: [1,2,3], b: {c: "4"}}
+                      unicode_bom: "\xef\xbb\xbfquery"
+                      keywordEnum: on
+                    )
+                  }
+                |}
+
+                let(:inputs) { document.definitions.first.selections.first.arguments }
+
+                it "parses ints" do
+                  assert_equal 3, inputs[0].value
+                end
+
+                it "parses floats" do
+                  assert_equal 0.47e-23, inputs[1].value
+                end
+
+                it "parses booleans" do
+                  assert_equal false, inputs[2].value
+                end
+
+                it "parses UTF-8 strings" do
+                  assert_equal %|☀︎🏆\n escaped " unicode ¶ /|, inputs[3].value
+                end
+
+                it "parses enums" do
+                  assert_instance_of GraphQL::Language::Nodes::Enum, inputs[4].value
+                  assert_equal "ENUM_NAME", inputs[4].value.name
+                end
+
+                it "parses arrays" do
+                  assert_equal [7,8,9], inputs[5].value
+                end
+
+                it "parses objects" do
+                  obj = inputs[6].value
+                  assert_equal "a", obj.arguments[0].name
+                  assert_equal [1,2,3], obj.arguments[0].value
+                  assert_equal "b", obj.arguments[1].name
+                  assert_equal "c", obj.arguments[1].value.arguments[0].name
+                  assert_equal "4", obj.arguments[1].value.arguments[0].value
+                end
+
+                it "parses unicode bom" do
+                  obj = inputs[7].value
+                  assert_equal %|\xef\xbb\xbfquery|, inputs[7].value
+                end
+
+                it "parses enum 'on''" do
+                  assert_equal "on", inputs[8].value.name
+                end
+              end
+            end
+
+            describe "unnamed queries" do
+              let(:query_string) {%|
+                { name, age, height }
+              |}
+              let(:operation) { document.definitions.first }
+
+              it "parses unnamed queries" do
+                assert_equal 1, document.definitions.length
+                assert_equal "query", operation.operation_type
+                assert_equal nil, operation.name
+                assert_equal 3, operation.selections.length
+              end
+            end
+
+            describe "introspection query" do
+              let(:query_string) { GraphQL::Introspection::INTROSPECTION_QUERY }
+
+              it "parses a big ol' query" do
+                assert(document)
+              end
+            end
+
+            describe "schema" do
+              it "parses the test schema" do
+                schema = DummySchema
+                schema_string = GraphQL::Schema::Printer.print_schema(schema)
+                document = subject.parse(schema_string)
+
+                assert_equal schema_string, document.to_query_string
+              end
+
+              it "parses mimal schema definition" do
+                document = subject.parse('schema { query: QueryRoot }')
+
+                schema = document.definitions.first
+                assert_equal 'QueryRoot', schema.query
+                assert_equal nil, schema.mutation
+                assert_equal nil, schema.subscription
+              end
+
+              it "parses full schema definitions" do
+                document = subject.parse('
+                  schema {
+                    query: QueryRoot
+                    mutation: MutationRoot
+                    subscription: SubscriptionRoot
+                  }
+                ')
+
+                schema = document.definitions.first
+                assert_equal 'QueryRoot', schema.query
+                assert_equal 'MutationRoot', schema.mutation
+                assert_equal 'SubscriptionRoot', schema.subscription
+              end
+
+              it "parses object types" do
+                document = subject.parse('
+                  type Comment implements Node {
+                    id: ID!
+                  }
+                ')
+
+                type = document.definitions.first
+                assert_equal GraphQL::Language::Nodes::ObjectTypeDefinition, type.class
+                assert_equal 'Comment', type.name
+                assert_equal ['Node'], type.interfaces
+                assert_equal ['id'], type.fields.map(&:name)
+                assert_equal [], type.fields[0].arguments
+                assert_equal 'ID', type.fields[0].type.of_type.name
+              end
+
+              it "parses field arguments" do
+                document = subject.parse('
+                  type Mutation {
+                    post(id: ID!, data: PostData = { message: "First!1!", type: BLOG, tags: ["Test", "Annoying"] }): Post
+                  }
+                ')
+
+                field = document.definitions.first.fields.first
+                assert_equal ['id', 'data'], field.arguments.map(&:name)
+                data_arg = field.arguments[1]
+                assert_equal 'PostData', data_arg.type.name
+                assert_equal ['message', 'type', 'tags'], data_arg.default_value.arguments.map(&:name)
+                tags_arg = data_arg.default_value.arguments[2]
+                assert_equal ['Test', 'Annoying'], tags_arg.value
+              end
+
+              it "parses scalar types" do
+                document = subject.parse('scalar DateTime')
+
+                type = document.definitions.first
+                assert_equal GraphQL::Language::Nodes::ScalarTypeDefinition, type.class
+                assert_equal 'DateTime', type.name
+              end
+
+              it "parses interface types" do
+                document = subject.parse('
+                  interface Node {
+                    id: ID!
+                  }
+                ')
+
+                type = document.definitions.first
+                assert_equal GraphQL::Language::Nodes::InterfaceTypeDefinition, type.class
+                assert_equal 'Node', type.name
+                assert_equal ['id'], type.fields.map(&:name)
+                assert_equal [], type.fields[0].arguments
+                assert_equal 'ID', type.fields[0].type.of_type.name
+              end
+
+              it "parses enum types" do
+                document = subject.parse('
+                  enum DogCommand { SIT, DOWN, HEEL }
+                ')
+
+                type = document.definitions.first
+                assert_equal GraphQL::Language::Nodes::EnumTypeDefinition, type.class
+                assert_equal 'DogCommand', type.name
+                assert_equal ['SIT', 'DOWN', 'HEEL'], type.values
+              end
+
+              it "parses input object types" do
+                document = subject.parse('
+                  input EmptyMutationInput {
+                    clientMutationId: String
+                  }
+                ')
+
+                type = document.definitions.first
+                assert_equal GraphQL::Language::Nodes::InputObjectTypeDefinition, type.class
+                assert_equal 'EmptyMutationInput', type.name
+                assert_equal ['clientMutationId'], type.fields.map(&:name)
+                assert_equal 'String', type.fields[0].type.name
+                assert_equal nil, type.fields[0].default_value
+              end
+            end
+          end
+
+          describe "errors" do
+            let(:query_string) {%| query doSomething { bogus { } |}
+            it "raises a parse error" do
+              err = assert_raises(GraphQL::ParseError) { document }
+            end
+
+            it "correctly identifies parse error location and content" do
+              e = assert_raises(GraphQL::ParseError) do
+                GraphQL.parse("
+                  query getCoupons {
+                    allCoupons: {data{id}}
+                  }
+                ")
+              end
+              assert_includes(e.message, '"{"')
+              assert_includes(e.message, "RCURLY")
+              assert_equal(3, e.line)
+              assert_equal(33, e.col)
+            end
+
+            it "handles unexpected ends" do
+              err = assert_raises(GraphQL::ParseError) { GraphQL.parse("{ ") }
+              assert_equal "Unexpected end of document", err.message
+            end
+
+            it "rejects unsupported characters" do
+              e = assert_raises(GraphQL::ParseError) do
+                GraphQL.parse("{ field; }")
+              end
+
+              assert_includes(e.message, "Parse error on \";\"")
+            end
+
+            it "rejects control characters" do
+              e = assert_raises(GraphQL::ParseError) do
+                GraphQL.parse("{ \afield }")
+              end
+
+              assert_includes(e.message, "Parse error on \"\\a\"")
+            end
+
+            it "rejects partial BOM" do
+              e = assert_raises(GraphQL::ParseError) do
+                GraphQL.parse("{ \xeffield }")
+              end
+
+              assert_includes(e.message, "Parse error on \"\\xEF\"")
+            end
+
+            it "rejects vertical tabs" do
+              e = assert_raises(GraphQL::ParseError) do
+                GraphQL.parse("{ \vfield }")
+              end
+
+              assert_includes(e.message, "Parse error on \"\\v\"")
+            end
+
+            it "rejects form feed" do
+              e = assert_raises(GraphQL::ParseError) do
+                GraphQL.parse("{ \ffield }")
+              end
+
+              assert_includes(e.message, "Parse error on \"\\f\"")
+            end
+
+            it "rejects no break space" do
+              e = assert_raises(GraphQL::ParseError) do
+                GraphQL.parse("{ \xa0field }")
+              end
+
+              assert_includes(e.message, "Parse error on \"\\xA0\"")
+            end
+
+            it "rejects unterminated strings" do
+              e = assert_raises(GraphQL::ParseError) do
+                GraphQL.parse("\"")
+              end
+
+              assert_includes(e.message, "Parse error on \"\\\"\"")
+
+              e = assert_raises(GraphQL::ParseError) do
+                GraphQL.parse("\"\n\"")
+              end
+
+              assert_includes(e.message, "Parse error on \"\\n\"")
+            end
+
+            it "rejects bad escape sequence in strings" do
+              e = assert_raises(GraphQL::ParseError) do
+                GraphQL.parse("{ field(arg:\"\\x\") }")
+              end
+
+              assert_includes(e.message, "Parse error on bad Unicode escape sequence")
+            end
+
+            it "rejects incomplete escape sequence in strings" do
+              e = assert_raises(GraphQL::ParseError) do
+                GraphQL.parse("{ field(arg:\"\\u1\") }")
+              end
+
+              assert_includes(e.message, "bad Unicode escape sequence")
+            end
+
+            it "rejects unicode escape with bad chars" do
+              e = assert_raises(GraphQL::ParseError) do
+                GraphQL.parse("{ field(arg:\"\\u0XX1\") }")
+              end
+
+              assert_includes(e.message, "bad Unicode escape sequence")
+
+              e = assert_raises(GraphQL::ParseError) do
+                GraphQL.parse("{ field(arg:\"\\uXXXX\") }")
+              end
+
+              assert_includes(e.message, "bad Unicode escape sequence")
+
+
+              e = assert_raises(GraphQL::ParseError) do
+                GraphQL.parse("{ field(arg:\"\\uFXXX\") }")
+              end
+
+              assert_includes(e.message, "bad Unicode escape sequence")
+
+
+              e = assert_raises(GraphQL::ParseError) do
+                GraphQL.parse("{ field(arg:\"\\uXXXF\") }")
+              end
+
+              assert_includes(e.message, "bad Unicode escape sequence")
+            end
+
+            it "rejects fragments named 'on'" do
+              e = assert_raises(GraphQL::ParseError) do
+                GraphQL.parse("fragment on on on { on }")
+              end
+
+              assert_includes(e.message, "Parse error on \"on\"")
+            end
+
+            it "rejects fragment spread of 'on'" do
+              e = assert_raises(GraphQL::ParseError) do
+                GraphQL.parse("{ ...on }")
+              end
+
+              assert_includes(e.message, "Parse error on \"}\"")
+            end
+
+            it "rejects null value" do
+              e = assert_raises(GraphQL::ParseError) do
+                GraphQL.parse("{ fieldWithNullableStringInput(input: null) }")
+              end
+
+              assert_includes(e.message, "Parse error on \"null\"")
+            end
+          end
+
+
+          describe "whitespace" do
+            describe "whitespace-only queries" do
+              let(:query_string) { " " }
+              it "doesn't blow up" do
+                assert_equal [], document.definitions
+              end
+            end
+
+            describe "empty string queries" do
+              let(:query_string) { "" }
+              it "doesn't blow up" do
+                assert_equal [], document.definitions
+              end
+            end
+
+            describe "using tabs as whitespace" do
+              let(:query_string) { "\t{\t\tid, \tname}"}
+              it "parses the query" do
+                assert_equal 1, document.definitions.length
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end