graphql 0.18.15 → 0.19.0

data/lib/graphql/schema/unique_within_type.rb

@@ -0,0 +1,28 @@
+module GraphQL
+  class Schema
+    module UniqueWithinType
+      DEFAULT_SEPARATOR = "-"
+
+      module_function
+
+      # @param type_name [String]
+      # @param object_value [Any]
+      # @return [String] a unique, opaque ID generated as a function of the two inputs
+      def encode(type_name, object_value, separator: DEFAULT_SEPARATOR)
+        object_value_str = object_value.to_s
+
+        if type_name.include?(separator) || object_value_str.include?(separator)
+          raise "encode(#{type_name}, #{object_value_str}) contains reserved characters `#{separator}`"
+        end
+
+        Base64.strict_encode64([type_name, object_value_str].join(separator))
+      end
+
+      # @param node_id [String] A unique ID generated by {.encode}
+      # @return [Array<(String, String)>] The type name & value passed to {.encode}
+      def decode(node_id, separator: DEFAULT_SEPARATOR)
+        Base64.decode64(node_id).split(separator)
+      end
+    end
+  end
+end

data/lib/graphql/schema/validation.rb

@@ -100,9 +100,16 @@ module GraphQL
 
         DEFAULT_VALUE_IS_VALID_FOR_TYPE = -> (type) {
           if !type.default_value.nil?
-            coerced_value = type.type.coerce_input(type.default_value)
-            if coerced_value.nil?
-              "default value #{type.default_value.inspect} is not valid for type #{type.type}"
+            coerced_value = begin
+              type.type.coerce_result(type.default_value)
+            rescue => ex
+              ex
+            end
+
+            if coerced_value.nil? || coerced_value.is_a?(StandardError)
+              msg = "default value #{type.default_value.inspect} is not valid for type #{type.type}"
+              msg += " (#{coerced_value})" if coerced_value.is_a?(StandardError)
+              msg
             end
           end
         }

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

@@ -76,7 +76,7 @@ module GraphQL
 
           args = defs.map { |defn| reduce_list(defn.arguments)}.uniq
           if args.length != 1
-            errors << message("Field '#{name}' has an argument conflict: #{args.map {|a| JSON.dump(a) }.join(" or ")}?", defs.first, context: context)
+            errors << message("Field '#{name}' has an argument conflict: #{args.map {|a| print_arg(a) }.join(" or ")}?", defs.first, context: context)
           end
 
           @errors = errors
@@ -84,6 +84,14 @@ module GraphQL
 
         private
 
+        def print_arg(arg)
+          case arg
+          when GraphQL::Language::Nodes::VariableIdentifier
+            "$#{arg.name}"
+          else
+            JSON.dump(arg)
+          end
+        end
         # Turn AST tree into a hash
         # can't look up args, the names just have to match
         def reduce_list(args)

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

@@ -23,8 +23,10 @@ module GraphQL
         context.visitor[GraphQL::Language::Nodes::Document].leave << -> (doc_node, parent) {
           spreads_to_validate.each do |frag_spread|
             fragment_child_name = context.fragments[frag_spread.node.name].type
-            fragment_child = context.schema.types[fragment_child_name]
-            validate_fragment_in_scope(frag_spread.parent_type, fragment_child, frag_spread.node, context, frag_spread.path)
+            fragment_child = context.schema.types.fetch(fragment_child_name, nil) # Might be non-existent type name
+            if fragment_child
+              validate_fragment_in_scope(frag_spread.parent_type, fragment_child, frag_spread.node, context, frag_spread.path)
+            end
           end
         }
       end
@@ -32,6 +34,10 @@ module GraphQL
       private
 
       def validate_fragment_in_scope(parent_type, child_type, node, context, path)
+        if !child_type.kind.fields?
+          # It's not a valid fragment type, this error was handled someplace else
+          return
+        end
         intersecting_types = get_possible_types(parent_type, context.schema) & get_possible_types(child_type, context.schema)
         if intersecting_types.none?
           name = node.respond_to?(:name) ? " #{node.name}" : ""

data/lib/graphql/type_kinds.rb

@@ -3,14 +3,15 @@ module GraphQL
   module TypeKinds
     # These objects are singletons, eg `GraphQL::TypeKinds::UNION`, `GraphQL::TypeKinds::SCALAR`.
     class TypeKind
-      attr_reader :name
-      def initialize(name, resolves: false, fields: false, wraps: false, input: false)
+      attr_reader :name, :description
+      def initialize(name, resolves: false, fields: false, wraps: false, input: false, description: nil)
         @name = name
         @resolves = resolves
         @fields = fields
         @wraps = wraps
         @input = input
         @composite = fields? || resolves?
+        @description = description
       end
 
       # Does this TypeKind have multiple possible implementors?
@@ -27,19 +28,18 @@ module GraphQL
     end
 
     TYPE_KINDS = [
-      SCALAR =        TypeKind.new("SCALAR", input: true),
-      OBJECT =        TypeKind.new("OBJECT", fields: true),
-      INTERFACE =     TypeKind.new("INTERFACE", resolves: true, fields: true),
-      UNION =         TypeKind.new("UNION", resolves: true),
-      ENUM =          TypeKind.new("ENUM", input: true),
-      INPUT_OBJECT =  TypeKind.new("INPUT_OBJECT", input: true),
-      LIST =          TypeKind.new("LIST", wraps: true),
-      NON_NULL =      TypeKind.new("NON_NULL", wraps: true),
+      SCALAR =        TypeKind.new("SCALAR", input: true, description: 'Indicates this type is a scalar.'),
+      OBJECT =        TypeKind.new("OBJECT", fields: true, description: 'Indicates this type is an object. `fields` and `interfaces` are valid fields.'),
+      INTERFACE =     TypeKind.new("INTERFACE", resolves: true, fields: true, description: 'Indicates this type is an interface. `fields` and `possibleTypes` are valid fields.'),
+      UNION =         TypeKind.new("UNION", resolves: true, description: 'Indicates this type is a union. `possibleTypes` is a valid field.'),
+      ENUM =          TypeKind.new("ENUM", input: true, description: 'Indicates this type is an enum. `enumValues` is a valid field.'),
+      INPUT_OBJECT =  TypeKind.new("INPUT_OBJECT", input: true, description: 'Indicates this type is an input object. `inputFields` is a valid field.'),
+      LIST =          TypeKind.new("LIST", wraps: true, description: 'Indicates this type is a list. `ofType` is a valid field.'),
+      NON_NULL =      TypeKind.new("NON_NULL", wraps: true, description: 'Indicates this type is a non-null. `ofType` is a valid field.'),
     ]
 
-    KIND_NAMES = TYPE_KINDS.map(&:name)
     class TypeKind
-      KIND_NAMES.each do |kind_name|
+      TYPE_KINDS.map(&:name).each do |kind_name|
         define_method("#{kind_name.downcase}?") do
           self.name == kind_name
         end

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.18.15"
+  VERSION = "0.19.0"
 end

data/readme.md

@@ -114,7 +114,7 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
 
 ## To Do
 
-- StaticValidation improvements
+- StaticValidation improvements ([in progress](https://github.com/rmosolgo/graphql-ruby/pull/268))
   - Use catch-all type/field/argument definitions instead of terminating traversal
   - Reduce ad-hoc traversals?
   - Validators are order-dependent, is this a smell?
@@ -123,17 +123,16 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
 - Add Rails-y argument validations, eg `less_than: 100`, `max_length: 255`, `one_of: [...]`
   - Must be customizable
 - Relay:
-  - `GlobalNodeIdentification.to_global_id` should receive the type name and _object_, not `id`. (Or, maintain the "`type_name, id` in, `type_name, id` out" pattern?)
   - Reduce duplication in ArrayConnection / RelationConnection
   - Improve API for creating edges (better RANGE_ADD support)
   - If the new edge isn't a member of the connection's objects, raise a nice error
 - Missing Enum value should raise a descriptive error, not "key not found"
 - `args` should whitelist keys -- if you request a key that isn't defined for the field, it should 💥
-- Fix middleware
+- Fix middleware ([discussion](https://github.com/rmosolgo/graphql-ruby/issues/186))
   - Handle out-of-bounds lookup, eg `graphql-batch`
   - Handle non-serial execution, eg `@defer`
 - Support non-instance-eval `.define`, eg `.define { |defn| ... }`
-- First-class promise support
+- First-class promise support ([discussion](https://github.com/rmosolgo/graphql-ruby/issues/274))
   - like `graphql-batch` but more local
   - support promises in connection resolves
 - Add immutable transformation API to AST
@@ -141,10 +140,12 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
   - Adding fields to selections (`__typename` can go anywhere, others are type-specific)
   - Renaming fragments from local names to unique names
 - Support AST subclasses? This would be hard, I think classes are used as hash keys in many places.
-- Support object deep-copy (schema, type, field, argument)? To support multiple schemas based on the same types.
+- Support object deep-copy (schema, type, field, argument)? To support multiple schemas based on the same types. ([discussion](https://github.com/rmosolgo/graphql-ruby/issues/269))
 - Improve the website
   - Feature the logo in the header
   - Split `readme.md` into `index.md` (a homepage with code samples) and a technical readme (how to install, link to homepage)
   - Move "Related projects" to a guide
   - Revisit guides, maybe split them into smaller, more specific pages
   - Put guide titles into the `<title />`
+- Document encrypted & versioned cursors
+- Eager load `Schema#types` after `.define { ... }`

data/spec/graphql/argument_spec.rb

@@ -15,7 +15,7 @@ describe GraphQL::Argument do
     }
 
     expected_error = %|Query is invalid: field "invalid" argument "invalid" default value ["123"] is not valid for type Float|
-    assert_equal expected_error, err.message
+    assert_includes err.message, expected_error
   end
 
   it "accepts proc type" do

data/spec/graphql/execution_error_spec.rb

@@ -118,4 +118,57 @@ describe GraphQL::ExecutionError do
       assert_equal(expected_result, result)
     end
   end
+
+  describe "named query when returned from a field" do
+    let(:query_string) {%|
+    query MilkQuery {
+      dairy {
+        milks {
+          source
+          executionError
+          allDairy {
+            __typename
+            ... on Milk {
+              origin
+              executionError
+            }
+          }
+        }
+      }
+    }
+    |}
+    it "the error is inserted into the errors key and the rest of the query is fulfilled" do
+      expected_result = {
+        "data"=>{
+            "dairy" => {
+              "milks" => [
+                {
+                  "source" => "COW",
+                  "executionError" => nil,
+                  "allDairy" => [
+                    { "__typename" => "Cheese" },
+                    { "__typename" => "Cheese" },
+                    { "__typename" => "Cheese" },
+                    { "__typename" => "Milk", "origin" => "Antiquity", "executionError" => nil }
+                  ]
+                }
+              ]
+            }
+          },
+          "errors"=>[
+            {
+              "message"=>"There was an execution error",
+              "locations"=>[{"line"=>6, "column"=>11}],
+              "path"=>["dairy", "milks", 0, "executionError"]
+            },
+            {
+              "message"=>"There was an execution error",
+              "locations"=>[{"line"=>11, "column"=>15}],
+              "path"=>["dairy", "milks", 0, "allDairy", 3, "executionError"]
+            }
+          ]
+        }
+      assert_equal(expected_result, result)
+    end
+  end
 end

data/spec/graphql/introspection/directive_type_spec.rb

@@ -42,6 +42,16 @@ describe GraphQL::Introspection::DirectiveType do
             "onFragment" => true,
             "onOperation" => false,
           },
+          {
+            "name" => "deprecated",
+            "args" => [
+              {"name"=>"reason", "type"=>{"name"=>"String", "ofType"=>nil}}
+            ],
+            "locations"=>["FIELD_DEFINITION", "ENUM_VALUE"],
+            "onField" => false,
+            "onFragment" => false,
+            "onOperation" => false,
+          },
         ]
       }
     }}

data/spec/graphql/introspection/input_value_type_spec.rb

@@ -39,4 +39,27 @@ describe GraphQL::Introspection::InputValueType do
       }}
     assert_equal(expected, result)
   end
+
+  let(:cheese_type) {
+    DummySchema.execute(%|
+      {
+        __type(name: "Cheese") {
+          fields {
+            name
+            args {
+              name
+              defaultValue
+            }
+          }
+        }
+      }
+    |)
+  }
+
+  it "converts default values to GraphQL values" do
+    field = cheese_type['data']['__type']['fields'].detect { |f| f['name'] == 'similarCheese' }
+    arg = field['args'].detect { |a| a['name'] == 'source' }
+
+    assert_equal('["COW"]', arg['defaultValue'])
+  end
 end

data/spec/graphql/language/generation_spec.rb

@@ -96,6 +96,10 @@ describe GraphQL::Language::Generation do
         input AnnotatedInput @onInputObjectType {
           annotatedField: Type @onField
         }
+
+        directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+        directive @include(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
       schema
       }
 

data/spec/graphql/query/executor_spec.rb

@@ -144,7 +144,7 @@ describe GraphQL::Query::Executor do
             {
               "message" => "BOOM",
               "locations" => [ { "line" => 1, "column" => 28 } ],
-              "path" => ["noMilk", "cow", "cantBeNullButRaisesExecutionError"]
+              "path" => ["cow", "cantBeNullButRaisesExecutionError"]
             }
           ]
         }
@@ -169,7 +169,7 @@ describe GraphQL::Query::Executor do
             {
               "message"=>"Error was handled!",
               "locations" => [{"line"=>1, "column"=>17}],
-              "path"=>["noMilk", "error"]
+              "path"=>["error"]
             }
           ]
         }

data/spec/graphql/relay/mutation_spec.rb

@@ -33,7 +33,7 @@ describe GraphQL::Relay::Mutation do
         "shipEdge" => {
           "node" => {
             "name" => "Bagel",
-            "id" => NodeIdentification.to_global_id("Ship", "9"),
+            "id" => GraphQL::Schema::UniqueWithinType.encode("Ship", "9"),
           },
         },
         "faction" => {"name" => STAR_WARS_DATA["Faction"]["1"].name }

data/spec/graphql/relay/node_spec.rb

@@ -0,0 +1,87 @@
+require "spec_helper"
+
+describe GraphQL::Relay::Node do
+  describe ".field" do
+    describe "Custom global IDs" do
+      before do
+        # TODO: make the schema eager-load so we can remove this
+        # Ensure the schema is defined:
+        StarWarsSchema.types
+
+        @previous_id_from_object_proc = StarWarsSchema.id_from_object_proc
+        @previous_object_from_id_proc = StarWarsSchema.object_from_id_proc
+
+        StarWarsSchema.id_from_object = -> (obj, type_name, ctx) {
+          "#{type_name}/#{obj.id}"
+        }
+
+        StarWarsSchema.object_from_id = -> (global_id, ctx) {
+          type_name, id = global_id.split("/")
+          STAR_WARS_DATA[type_name][id]
+        }
+      end
+
+      after do
+        StarWarsSchema.id_from_object = @previous_id_from_object_proc
+        StarWarsSchema.object_from_id = @previous_object_from_id_proc
+      end
+
+      it "Deconstructs the ID by the custom proc" do
+        result = star_wars_query(%| { node(id: "Base/1") { ... on Base { name } } }|)
+        base_name = result["data"]["node"]["name"]
+        assert_equal "Yavin", base_name
+      end
+
+      describe "generating IDs" do
+        it "Applies custom-defined ID generation" do
+          result = star_wars_query(%| { largestBase { id } }|)
+          generated_id = result["data"]["largestBase"]["id"]
+          assert_equal "Base/3", generated_id
+        end
+      end
+    end
+
+    describe "setting a description" do
+      it "allows you to set a description" do
+        node_field = GraphQL::Relay::Node.field
+        node_field.description = "Hello, World!"
+        assert_equal "Hello, World!", node_field.description
+      end
+    end
+
+
+    it 'finds objects by id' do
+      id = GraphQL::Schema::UniqueWithinType.encode("Faction", "1")
+      result = star_wars_query(%|{
+        node(id: "#{id}") {
+          id,
+          ... on Faction {
+            name
+            ships(first: 1) {
+              edges {
+               node {
+                 name
+                 }
+              }
+            }
+          }
+        }
+      }|)
+      expected = {"data" => {
+        "node"=>{
+          "id"=>"RmFjdGlvbi0x",
+          "name"=>"Alliance to Restore the Republic",
+          "ships"=>{
+            "edges"=>[
+              {"node"=>{
+                  "name" => "X-Wing"
+                }
+              }
+            ]
+          }
+        }
+      }}
+      assert_equal(expected, result)
+    end
+  end
+end

data/spec/graphql/schema/catchall_middleware_spec.rb

@@ -22,7 +22,7 @@ describe GraphQL::Schema::CatchallMiddleware do
           {
             "message"=>"Internal error",
             "locations"=>[{"line"=>1, "column"=>17}],
-            "path"=>["noMilk", "error"]
+            "path"=>["error"]
           },
         ]
       }

data/spec/graphql/schema/loader_spec.rb

@@ -11,7 +11,7 @@ describe GraphQL::Schema::Loader do
     choice_type = GraphQL::EnumType.define do
       name "Choice"
 
-      value "FOO"
+      value "FOO", value: :foo
       value "BAR"
     end
 
@@ -30,7 +30,7 @@ describe GraphQL::Schema::Loader do
       name "Varied"
       input_field :id, types.ID
       input_field :int, types.Int
-      input_field :bigint, big_int_type
+      input_field :bigint, big_int_type, default_value: 2**54
       input_field :float, types.Float
       input_field :bool, types.Boolean
       input_field :enum, choice_type
@@ -43,6 +43,10 @@ describe GraphQL::Schema::Loader do
       interfaces [node_type]
 
       field :body, !types.String
+
+      field :fieldWithArg, types.Int do
+        argument :bigint, big_int_type, default_value: 2**54
+      end
     end
 
     media_type = GraphQL::InterfaceType.define do
@@ -85,7 +89,7 @@ describe GraphQL::Schema::Loader do
       field :post do
         type post_type
         argument :id, !types.ID
-        argument :varied, variant_input_type, default_value: { id: "123", int: 234, float: 2.3, enum: "FOO", sub: [{ string: "str" }] }
+        argument :varied, variant_input_type, default_value: { id: "123", int: 234, float: 2.3, enum: :foo, sub: [{ string: "str" }] }
       end
 
       field :content do
@@ -166,8 +170,37 @@ describe GraphQL::Schema::Loader do
       end
     end
 
+    let(:loaded_schema) { GraphQL::Schema::Loader.load(schema_json) }
+
     it "returns the schema" do
-      assert_deep_equal(schema, GraphQL::Schema::Loader.load(schema_json))
+      assert_deep_equal(schema, loaded_schema)
+    end
+
+    it "can export the loaded schema" do
+      assert loaded_schema.execute(GraphQL::Introspection::INTROSPECTION_QUERY)
+    end
+
+    it "sets correct default values on custom scalar arguments" do
+      type = loaded_schema.types["Comment"]
+      field = type.fields['fieldWithArg']
+      arg = field.arguments['bigint']
+
+      assert_equal((2**54).to_s, arg.default_value)
+    end
+
+    it "sets correct default values on custom scalar input fields" do
+      type = loaded_schema.types["Varied"]
+      field = type.input_fields['bigint']
+
+      assert_equal((2**54).to_s, field.default_value)
+    end
+
+    it "sets correct default values for complex field arguments" do
+      type = loaded_schema.types['Query']
+      field = type.fields['post']
+      arg = field.arguments['varied']
+
+      assert_equal arg.default_value, { 'id' => "123", 'bigint' => nil, 'bool' => nil, 'int' => 234, 'float' => 2.3, 'enum' => "FOO", 'sub' => [{ 'string' => "str" }] }
     end
   end
 end