graphql 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 69c8b3d44df121369cc6c809f94584316ae60580
-  data.tar.gz: cd20f49dd30f703c25fd3bb336b33de610d5885e
+  metadata.gz: 1d1d8b93486b17d67f6714c1ad867c5f5eb403a4
+  data.tar.gz: 68dc546c4124fd8fb3752c911b63be9f9753ffc2
 SHA512:
-  metadata.gz: 52474d43d5e821f1d594214bb583fd8c9042e084afbf8222b389de22e4ed091c3a1d37ae5efdb4473d5fd4a3b6733d2b4b731a430d28e398632987ed68e964cf
-  data.tar.gz: 63a46420973ab26b529b80e1867d9a809ddbab828d4462e43eb0aafb0ede0417d58a9f308d9c9c3c5f5dadab2f0f265b2fb6effade39510adb45ee53109080bd
+  metadata.gz: eb42f273418ba3eda88ca784f3af4a20b0a57223b02adbf64736953446312e87ece3392f2c7b3d696ebbd66cecc8a38809ff6ff79bb623942dd6bced33c4f5bc
+  data.tar.gz: 54669eb238917fedceba3df22ac927461a0a427b1d259a3277e6be1ffef420ada7ee1fc5abd63f605a4d5397e88a23d1d8ea73f95ebfd9cbaa97554b09b05089

data/lib/graphql.rb

@@ -27,6 +27,15 @@ module GraphQL
   def self.parse_with_racc(string)
     GraphQL::Language::Parser.parse(string)
   end
+
+  # @return [Array<GraphQL::Language::Token>]
+  def self.scan(query_string)
+    scan_with_ragel(query_string)
+  end
+
+  def self.scan_with_ragel(query_string)
+    GraphQL::Language::Lexer.tokenize(query_string)
+  end
 end
 
 # Order matters for these:
@@ -73,3 +82,4 @@ require "graphql/static_validation"
 require "graphql/version"
 require "graphql/relay"
 require "graphql/execution"
+require "graphql/compatibility"

data/lib/graphql/base_type.rb

@@ -61,13 +61,16 @@ module GraphQL
 
     alias :inspect :to_s
 
-    def valid_input?(value)
-      validate_input(value).valid?
+    def valid_input?(value, warden)
+      validate_input(value, warden).valid?
     end
 
-    def validate_input(value)
-      return GraphQL::Query::InputValidationResult.new if value.nil?
-      validate_non_null_input(value)
+    def validate_input(value, warden)
+      if value.nil?
+        GraphQL::Query::InputValidationResult.new
+      else
+        validate_non_null_input(value, warden)
+      end
     end
 
     def coerce_input(value)

data/lib/graphql/compatibility.rb

@@ -0,0 +1,3 @@
+require "graphql/compatibility/execution_specification"
+require "graphql/compatibility/query_parser_specification"
+require "graphql/compatibility/schema_parser_specification"

data/lib/graphql/compatibility/execution_specification.rb

@@ -0,0 +1,414 @@
+module GraphQL
+  module Compatibility
+    # Test an execution strategy. This spec is not meant as a development aid.
+    # Rather, when the strategy _works_, run it here to see if it has any differences
+    # from the built-in strategy.
+    #
+    # - Custom scalar input / output
+    # - Null propagation
+    # - Query-level masking
+    # - Directive support
+    # - Typecasting
+    # - Error handling (raise / return GraphQL::ExecutionError)
+    # - Provides Irep & AST node to resolve fn
+    #
+    # Some things are explicitly _not_ tested here, because they're handled
+    # by other parts of the system:
+    #
+    # - Schema definition (including types and fields)
+    # - Parsing & parse errors
+    # - AST -> IRep transformation (eg, fragment merging)
+    # - Query validation and analysis
+    # - Relay features
+    #
+    module ExecutionSpecification
+      DATA = {
+        "1001" => OpenStruct.new({
+          name: "Fannie Lou Hamer",
+          birthdate: Time.new(1917, 10, 6),
+          organization_ids: [],
+        }),
+        "1002" => OpenStruct.new({
+          name: "John Lewis",
+          birthdate: Time.new(1940, 2, 21),
+          organization_ids: ["2001"],
+        }),
+        "1003" => OpenStruct.new({
+          name: "Diane Nash",
+          birthdate: Time.new(1938, 5, 15),
+          organization_ids: ["2001", "2002"],
+        }),
+        "1004" => OpenStruct.new({
+          name: "Ralph Abernathy",
+          birthdate: Time.new(1926, 3, 11),
+          organization_ids: ["2002"],
+        }),
+        "2001" => OpenStruct.new({
+          name: "SNCC",
+          leader_id: nil, # fail on purpose
+        }),
+        "2002" => OpenStruct.new({
+          name: "SCLC",
+          leader_id: "1004",
+        }),
+      }
+
+      # Make a minitest suite for this execution strategy, making sure it
+      # fulfills all the requirements of this library.
+      # @param execution_strategy [<#new, #execute>] An execution strategy class
+      # @return [Class<Minitest::Test>] A test suite for this execution strategy
+      def self.build_suite(execution_strategy)
+        Class.new(Minitest::Test) do
+          def self.build_schema(execution_strategy)
+            organization_type = nil
+
+            timestamp_type = GraphQL::ScalarType.define do
+              name "Timestamp"
+              coerce_input ->(value) { Time.at(value.to_i) }
+              coerce_result ->(value) { value.to_i }
+            end
+
+            named_entity_interface_type = GraphQL::InterfaceType.define do
+              name "NamedEntity"
+              field :name, !types.String
+            end
+
+            person_type = GraphQL::ObjectType.define do
+              name "Person"
+              interfaces [named_entity_interface_type]
+              field :name, !types.String
+              field :birthdate, timestamp_type
+              field :age, types.Int do
+                argument :on, !timestamp_type
+                resolve ->(obj, args, ctx) {
+                  if obj.birthdate.nil?
+                    nil
+                  else
+                    age_on = args[:on]
+                    age_years = age_on.year - obj.birthdate.year
+                    this_year_birthday = Time.new(age_on.year, obj.birthdate.month, obj.birthdate.day)
+                    if this_year_birthday > age_on
+                      age_years -= 1
+                    end
+                  end
+                  age_years
+                }
+              end
+              field :organizations, types[organization_type] do
+                resolve ->(obj, args, ctx) {
+                  obj.organization_ids.map { |id| DATA[id] }
+                }
+              end
+              field :first_organization, !organization_type do
+                resolve ->(obj, args, ctx) {
+                  DATA[obj.organization_ids.first]
+                }
+              end
+            end
+
+            organization_type = GraphQL::ObjectType.define do
+              name "Organization"
+              interfaces [named_entity_interface_type]
+              field :name, !types.String
+              field :leader, !person_type do
+                resolve ->(obj, args, ctx) {
+                  DATA[obj.leader_id] || (ctx[:return_error] ? ExecutionError.new("Error on Nullable") : nil)
+                }
+              end
+              field :returnedError, types.String do
+                resolve ->(o, a, c) {
+                  GraphQL::ExecutionError.new("This error was returned")
+                }
+              end
+              field :raisedError, types.String do
+                resolve ->(o, a, c) {
+                  raise GraphQL::ExecutionError.new("This error was raised")
+                }
+              end
+
+              field :nodePresence, !types[!types.Boolean] do
+                resolve ->(o, a, ctx) {
+                  [
+                    ctx.irep_node.is_a?(GraphQL::InternalRepresentation::Node),
+                    ctx.ast_node.is_a?(GraphQL::Language::Nodes::AbstractNode),
+                    false, # just testing
+                  ]
+                }
+              end
+            end
+
+            node_union_type = GraphQL::UnionType.define do
+              name "Node"
+              possible_types [person_type, organization_type]
+            end
+
+            query_type = GraphQL::ObjectType.define do
+              name "Query"
+              field :node, node_union_type do
+                argument :id, !types.ID
+                resolve ->(obj, args, ctx) {
+                  obj[args[:id]]
+                }
+              end
+
+              field :organization, !organization_type do
+                argument :id, !types.ID
+                resolve ->(obj, args, ctx) {
+                  args[:id].start_with?("2") && obj[args[:id]]
+                }
+              end
+
+              field :organizations, types[organization_type] do
+                resolve ->(obj, args, ctx) {
+                  [obj["2001"], obj["2002"]]
+                }
+              end
+            end
+
+            GraphQL::Schema.define do
+              query_execution_strategy execution_strategy
+              query query_type
+
+              resolve_type ->(obj, ctx) {
+                obj.respond_to?(:birthdate) ? person_type : organization_type
+              }
+            end
+          end
+
+          @@schema = build_schema(execution_strategy)
+
+          def execute_query(query_string, **kwargs)
+            kwargs[:root_value] = DATA
+            @@schema.execute(query_string, **kwargs)
+          end
+
+          def test_it_fetches_data
+            query_string = %|
+            query getData($nodeId: ID = "1001") {
+              flh: node(id: $nodeId) {
+                __typename
+                ... on Person {
+                  name @include(if: true)
+                  skippedName: name @skip(if: true)
+                  birthdate
+                  age(on: 1477660133)
+                }
+
+                ... on NamedEntity {
+                  ne_tn: __typename
+                  ne_n: name
+                }
+
+                ... on Organization {
+                  org_n: name
+                }
+              }
+            }
+            |
+            res = execute_query(query_string)
+
+            assert_equal nil, res["errors"], "It doesn't have an errors key"
+
+            flh = res["data"]["flh"]
+            assert_equal "Fannie Lou Hamer", flh["name"], "It returns values"
+            assert_equal Time.new(1917, 10, 6).to_i, flh["birthdate"], "It returns custom scalars"
+            assert_equal 99, flh["age"], "It runs resolve functions"
+            assert_equal "Person", flh["__typename"], "It serves __typename"
+            assert_equal "Person", flh["ne_tn"], "It serves __typename on interfaces"
+            assert_equal "Fannie Lou Hamer", flh["ne_n"], "It serves interface fields"
+            assert_equal false, flh.key?("skippedName"), "It obeys @skip"
+            assert_equal false, flh.key?("org_n"), "It doesn't apply other type fields"
+          end
+
+          def test_it_propagates_nulls_to_field
+            query_string = %|
+            query getOrg($id: ID = "2001"){
+              failure: node(id: $id) {
+                ... on Organization {
+                  name
+                  leader { name }
+                }
+              }
+              success: node(id: $id) {
+                ... on Organization {
+                  name
+                }
+              }
+            }
+            |
+            res = execute_query(query_string)
+
+            failure = res["data"]["failure"]
+            success = res["data"]["success"]
+
+            assert_equal nil, failure, "It propagates nulls to the next nullable field"
+            assert_equal({"name" => "SNCC"}, success, "It serves the same object if no invalid null is encountered")
+            assert_equal 1, res["errors"].length , "It returns an error for the invalid null"
+          end
+
+          def test_it_propages_nulls_to_operation
+            query_string = %|
+              {
+                foundOrg: organization(id: "2001") {
+                  name
+                }
+                organization(id: "2999") {
+                  name
+                }
+              }
+            |
+
+            res = execute_query(query_string)
+            assert_equal nil, res["data"]
+            assert_equal 1, res["errors"].length
+          end
+
+          def test_it_exposes_raised_and_returned_user_execution_errors
+            query_string = %|
+              {
+                organization(id: "2001") {
+                  name
+                  returnedError
+                  raisedError
+                }
+                organizations {
+                  returnedError
+                  raisedError
+                }
+              }
+            |
+
+            res = execute_query(query_string)
+
+            assert_equal "SNCC", res["data"]["organization"]["name"], "It runs the rest of the query"
+
+            expected_errors = [
+              {
+                "message"=>"This error was returned",
+                "locations"=>[{"line"=>5, "column"=>19}],
+                "path"=>["organization", "returnedError"]
+              },
+              {
+                "message"=>"This error was raised",
+                "locations"=>[{"line"=>6, "column"=>19}],
+                "path"=>["organization", "raisedError"]
+              },
+              {
+                "message"=>"This error was raised",
+                "locations"=>[{"line"=>10, "column"=>19}],
+                "path"=>["organizations", 0, "raisedError"]
+              },
+              {
+                "message"=>"This error was raised",
+                "locations"=>[{"line"=>10, "column"=>19}],
+                "path"=>["organizations", 1, "raisedError"]
+              },
+              {
+                "message"=>"This error was returned",
+                "locations"=>[{"line"=>9, "column"=>19}],
+                "path"=>["organizations", 0, "returnedError"]
+              },
+              {
+                "message"=>"This error was returned",
+                "locations"=>[{"line"=>9, "column"=>19}],
+                "path"=>["organizations", 1, "returnedError"]
+              },
+            ]
+
+            expected_errors.each do |expected_err|
+              assert_includes res["errors"], expected_err
+            end
+          end
+
+          def test_it_applies_masking
+            no_org = ->(member) { member.name == "Organization" }
+            query_string = %|
+            {
+              node(id: "2001") {
+                __typename
+              }
+            }|
+
+            assert_raises(GraphQL::UnresolvedTypeError) {
+              execute_query(query_string, except: no_org)
+            }
+
+            query_string = %|
+            {
+              organization(id: "2001") { name }
+            }|
+
+            res = execute_query(query_string, except: no_org)
+
+            assert_equal nil, res["data"]
+            assert_equal 1, res["errors"].length
+
+            query_string = %|
+            {
+              __type(name: "Organization") { name }
+            }|
+
+            res = execute_query(query_string, except: no_org)
+
+            assert_equal nil, res["data"]["__type"]
+            assert_equal nil, res["errors"]
+          end
+
+          def test_it_provides_nodes_to_resolve
+            query_string = %|
+            {
+              organization(id: "2001") {
+                name
+                nodePresence
+              }
+            }|
+
+            res = execute_query(query_string)
+            assert_equal "SNCC", res["data"]["organization"]["name"]
+            assert_equal [true, true, false], res["data"]["organization"]["nodePresence"]
+          end
+
+          def test_it_runs_the_introspection_query
+            execute_query(GraphQL::Introspection::INTROSPECTION_QUERY)
+          end
+
+          def test_it_propagates_deeply_nested_nulls
+            query_string = %|
+            {
+              node(id: "1001") {
+                ... on Person {
+                  name
+                  first_organization {
+                    leader {
+                      name
+                    }
+                  }
+                }
+              }
+            }
+            |
+            res = execute_query(query_string)
+            assert_equal nil, res["data"]["node"]
+            assert_equal 1, res["errors"].length
+          end
+
+          def test_it_doesnt_add_errors_for_invalid_nulls_from_execution_errors
+            query_string = %|
+            query getOrg($id: ID = "2001"){
+              failure: node(id: $id) {
+                ... on Organization {
+                  name
+                  leader { name }
+                }
+              }
+            }
+            |
+            res = execute_query(query_string, context: {return_error: true})
+            error_messages = res["errors"].map { |e| e["message"] }
+            assert_equal ["Error on Nullable"], error_messages
+          end
+        end
+      end
+    end
+  end
+end