graphql 1.3.0 → 1.4.0

data/lib/graphql/schema/rescue_middleware.rb

@@ -30,9 +30,9 @@ module GraphQL
       end
 
       # Implement the requirement for {GraphQL::Schema::MiddlewareChain}
-      def call(*args, next_middleware)
+      def call(*args)
         begin
-          next_middleware.call
+          yield
         rescue StandardError => err
           attempt_rescue(err)
         end

data/lib/graphql/schema/timeout_middleware.rb

@@ -34,13 +34,13 @@ module GraphQL
         @error_handler = block
       end
 
-      def call(parent_type, parent_object, field_definition, field_args, query_context, next_middleware)
+      def call(parent_type, parent_object, field_definition, field_args, query_context)
         timeout_at = query_context[@context_key] ||= Time.now + @max_seconds
 
         if timeout_at < Time.now
           on_timeout(parent_type, parent_object, field_definition, field_args, query_context)
         else
-          next_middleware.call
+          yield
         end
       end
 

data/lib/graphql/schema/validation.rb

@@ -178,7 +178,7 @@ module GraphQL
         }
 
         RESERVED_TYPE_NAME = ->(type) {
-          if type.name.start_with?('__') && INTROSPECTION_TYPES[type.name] != type
+          if type.name.start_with?('__') && !type.introspection?
             # TODO: make this a hard failure in a later version
             warn("Name #{type.name.inspect} must not begin with \"__\", which is reserved by GraphQL introspection.")
             nil
@@ -246,17 +246,6 @@ module GraphQL
           Rules::SCHEMA_INSTRUMENTERS_ARE_VALID,
         ],
       }
-
-      INTROSPECTION_TYPES = Hash[[
-        GraphQL::Introspection::TypeType,
-        GraphQL::Introspection::TypeKindEnum,
-        GraphQL::Introspection::FieldType,
-        GraphQL::Introspection::InputValueType,
-        GraphQL::Introspection::EnumValueType,
-        GraphQL::Introspection::DirectiveType,
-        GraphQL::Introspection::DirectiveLocationEnum,
-        GraphQL::Introspection::SchemaType,
-      ].map{ |type| [type.name, type] }]
     end
   end
 end

data/lib/graphql/schema/warden.rb

@@ -12,7 +12,7 @@ module GraphQL
     # Masks can be provided in {Schema#execute} (or {Query#initialize}) with the `mask:` keyword.
     #
     # @example Hidding private fields
-    #   private_members = -> (member) { member.metadata[:private] }
+    #   private_members = -> (member, ctx) { member.metadata[:private] }
     #   result = Schema.execute(query_string, except: private_members)
     #
     # @example Custom mask implementation
@@ -23,7 +23,7 @@ module GraphQL
     #     end
     #
     #     # Return `false` if any required flags are missing
-    #     def call(member)
+    #     def call(member, ctx)
     #       member.metadata[:required_flags].any? do |flag|
     #         !@user.has_flag?(flag)
     #       end
@@ -36,69 +36,88 @@ module GraphQL
     #   # This query can only access members which match the user's flags
     #   result = Schema.execute(query_string, except: missing_required_flags)
     #
+    # @api private
     class Warden
+      # @param mask [<#call(member)>] Objects are hidden when `.call(member, ctx)` returns true
+      # @param context [GraphQL::Query::Context]
       # @param schema [GraphQL::Schema]
-      # @param mask [<#call(member)>] Objects are hidden when `.call(member)` returns true
-      def initialize(schema, mask)
+      # @param deep_check [Boolean]
+      def initialize(mask, context:, schema:)
         @mask = mask
+        @context = context
         @schema = schema
       end
 
       # @return [Array<GraphQL::BaseType>] Visible types in the schema
       def types
-        @schema.types.each_value.select { |t| visible?(t) }
+        @types ||= @schema.types.each_value.select { |t| visible?(t) }
       end
 
       # @return [GraphQL::BaseType, nil] The type named `type_name`, if it exists (else `nil`)
       def get_type(type_name)
-        type_defn = @schema.types.fetch(type_name, nil)
-        if type_defn && visible?(type_defn)
-          type_defn
-        else
-          nil
+        @visible_types ||= read_through do |name|
+          type_defn = @schema.types.fetch(name, nil)
+          if type_defn && visible?(type_defn)
+            type_defn
+          else
+            nil
+          end
         end
+
+        @visible_types[type_name]
       end
 
       # @return [GraphQL::Field, nil] The field named `field_name` on `parent_type`, if it exists
       def get_field(parent_type, field_name)
-        field_defn = @schema.get_field(parent_type, field_name)
-        if field_defn && visible_field?(field_defn)
-          field_defn
-        else
-          nil
+
+        @visible_parent_fields ||= read_through do |type|
+          read_through do |f_name|
+            field_defn = @schema.get_field(type, f_name)
+            if field_defn && visible_field?(field_defn)
+              field_defn
+            else
+              nil
+            end
+          end
         end
+
+        @visible_parent_fields[parent_type][field_name]
       end
 
       # @return [Array<GraphQL::BaseType>] The types which may be member of `type_defn`
       def possible_types(type_defn)
-        @schema.possible_types(type_defn).select { |t| visible?(t) }
+        @visible_possible_types ||= read_through { |type_defn| @schema.possible_types(type_defn).select { |t| visible?(t) } }
+        @visible_possible_types[type_defn]
       end
 
       # @param type_defn [GraphQL::ObjectType, GraphQL::InterfaceType]
       # @return [Array<GraphQL::Field>] Fields on `type_defn`
       def fields(type_defn)
-        type_defn.all_fields.select { |f| visible_field?(f) }
+        @visible_fields ||= read_through { |t| t.all_fields.select { |f| visible_field?(f) } }
+        @visible_fields[type_defn]
       end
 
       # @param argument_owner [GraphQL::Field, GraphQL::InputObjectType]
       # @return [Array<GraphQL::Argument>] Visible arguments on `argument_owner`
       def arguments(argument_owner)
-        argument_owner.arguments.each_value.select { |a| visible_field?(a) }
+        @visible_arguments ||= read_through { |o| o.arguments.each_value.select { |a| visible_field?(a) } }
+        @visible_arguments[argument_owner]
       end
 
       # @return [Array<GraphQL::EnumType::EnumValue>] Visible members of `enum_defn`
       def enum_values(enum_defn)
-        enum_defn.values.each_value.select { |enum_value_defn| visible?(enum_value_defn) }
+        @visible_enum_values ||= read_through { |e| e.values.each_value.select { |enum_value_defn| visible?(enum_value_defn) } }
+        @visible_enum_values[enum_defn]
       end
 
       # @return [Array<GraphQL::InterfaceType>] Visible interfaces implemented by `obj_type`
       def interfaces(obj_type)
-        obj_type.interfaces.select { |t| visible?(t) }
+        @visible_interfaces ||= read_through { |t| t.interfaces.select { |i| visible?(i) } }
+        @visible_interfaces[obj_type]
       end
 
-      # @return [Array<GraphQL::Field>] Visible input fields on `input_obj_type`
-      def input_fields(input_obj_type)
-        input_obj_type.arguments.each_value.select { |f| visible_field?(f) }
+      def directives
+        @schema.directives.each_value.select { |d| visible?(d) }
       end
 
       private
@@ -108,7 +127,12 @@ module GraphQL
       end
 
       def visible?(member)
-        !@mask.call(member)
+        @visibility_cache ||= read_through { |m| !@mask.call(m, @context) }
+        @visibility_cache[member]
+      end
+
+      def read_through
+        Hash.new { |h, k| h[k] = yield(k) }
       end
     end
   end

data/lib/graphql/static_validation/literal_validator.rb

@@ -34,7 +34,7 @@ module GraphQL
 
 
       def required_input_fields_are_present(type, ast_node)
-        required_field_names = @warden.input_fields(type)
+        required_field_names = @warden.arguments(type)
           .select { |f| f.type.kind.non_null? }
           .map(&:name)
         present_field_names = ast_node.arguments.map(&:name)
@@ -43,7 +43,7 @@ module GraphQL
       end
 
       def present_input_field_values_are_valid(type, ast_node)
-        field_map = @warden.input_fields(type).reduce({}) { |m, f| m[f.name] = f; m}
+        field_map = @warden.arguments(type).reduce({}) { |m, f| m[f.name] = f; m}
         ast_node.arguments.all? do |value|
           field = field_map[value.name]
           field && validate(value.value, field.type)

data/lib/graphql/string_type.rb

@@ -5,4 +5,5 @@ GraphQL::STRING_TYPE = GraphQL::ScalarType.define do
 
   coerce_result ->(value) { value.to_s }
   coerce_input ->(value) { value.is_a?(String) ? value : nil }
+  default_scalar true
 end

data/lib/graphql/union_type.rb

@@ -24,9 +24,15 @@ module GraphQL
   #  }
   #
   class UnionType < GraphQL::BaseType
-    accepts_definitions :possible_types, :resolve_type
+    accepts_definitions :possible_types
     ensure_defined :possible_types
 
+    def initialize
+      super
+      @dirty_possible_types = []
+      @clean_possible_types = nil
+    end
+
     def initialize_copy(other)
       super
       @clean_possible_types = nil

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.3.0"
+  VERSION = "1.4.0"
 end

data/readme.md

@@ -41,22 +41,3 @@ See "Getting Started" on the [website](https://rmosolgo.github.io/graphql-ruby/)
 - __Features & patches__ are welcome! Consider discussing it in an [issue](https://github.com/rmosolgo/graphql-ruby/issues) or in the [#ruby channel on Slack](https://graphql-slack.herokuapp.com/) to make sure we're on the same page.
 - __Run the tests__ with `rake test` or start up guard with `bundle exec guard`.
 - __Build the site__ with `rake site:serve`, then visit `http://localhost:4000/graphql-ruby/`.
-
-## To Do
-
-- 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?
-  - Tests for interference between validators are poor
-  - Maybe this is a candidate for a rewrite?
-- Relay:
-  - 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
-- `args` should whitelist keys -- if you request a key that isn't defined for the field, it should 💥
-- Support non-instance-eval `.define`, eg `.define { |defn| ... }`
-- Add immutable transformation API to AST
-  - Support working with AST as data
-  - Adding fields to selections (`__typename` can go anywhere, others are type-specific)
-  - Renaming fragments from local names to unique names

data/spec/graphql/directive/skip_directive_spec.rb

@@ -0,0 +1,8 @@
+require "spec_helper"
+
+describe GraphQL::Directive::SkipDirective do
+  let(:directive) { GraphQL::Directive::SkipDirective }
+  it "is a default directive" do
+    assert directive.default_directive?
+  end
+end

data/spec/graphql/directive_spec.rb

@@ -134,7 +134,7 @@ describe GraphQL::Directive do
           let(:skip?) { true }
           it "is included" do assert field_included? end
         end
-      end      
+      end
     end
     describe "when evaluating conflicting @skip and @include on query selection and fragment" do
       let(:query_string) {"
@@ -215,13 +215,19 @@ describe GraphQL::Directive do
   end
 
   describe "defining a directive" do
-    it "can accept an array of arguments" do
-      directive = GraphQL::Directive.define do
+    let(:directive) {
+      GraphQL::Directive.define do
         arguments [GraphQL::Argument.define(name: 'skip')]
       end
+    }
 
+    it "can accept an array of arguments" do
       assert_equal 1, directive.arguments.length
       assert_equal 'skip', directive.arguments.first.name
     end
+
+    it "is not default" do
+      assert_equal false, directive.default_directive?
+    end
   end
 end

data/spec/graphql/input_object_type_spec.rb

@@ -83,6 +83,22 @@ describe GraphQL::InputObjectType do
         end
       end
 
+      if ActionPack::VERSION::MAJOR > 3
+        describe "with a ActionController::Parameters" do
+          let(:input) do
+            ActionController::Parameters.new(
+              "source" => "COW",
+              "fatContent" => 0.4,
+            )
+          end
+          let(:result) { DairyProductInputType.validate_input(input, PermissiveWarden) }
+
+          it "returns a valid result" do
+            assert(result.valid?)
+          end
+        end
+      end
+
       describe "with bad enum and float" do
         let(:result) { DairyProductInputType.validate_input({"source" => "KOALA", "fatContent" => "bad_num"}, PermissiveWarden) }
 
@@ -106,6 +122,57 @@ describe GraphQL::InputObjectType do
         end
       end
 
+      describe 'with a string as input' do
+        let(:result) { DairyProductInputType.validate_input("just a string", PermissiveWarden) }
+
+        it "returns an invalid result" do
+          assert(!result.valid?)
+        end
+
+        it "has problem with correct path" do
+          paths = result.problems.map { |p| p["path"] }
+          assert(paths.include?([]))
+        end
+
+        it "has correct problem explanation" do
+          assert(result.problems[0]["explanation"].include?("to be a key, value object"))
+        end
+      end
+
+      describe 'with an array as input' do
+        let(:result) { DairyProductInputType.validate_input(["string array"], PermissiveWarden) }
+
+        it "returns an invalid result" do
+          assert(!result.valid?)
+        end
+
+        it "has problem with correct path" do
+          paths = result.problems.map { |p| p["path"] }
+          assert(paths.include?([]))
+        end
+
+        it "has correct problem explanation" do
+          assert(result.problems[0]["explanation"].include?("to be a key, value object"))
+        end
+      end
+
+      describe 'with a int as input' do
+        let(:result) { DairyProductInputType.validate_input(10, PermissiveWarden) }
+
+        it "returns an invalid result" do
+          assert(!result.valid?)
+        end
+
+        it "has problem with correct path" do
+          paths = result.problems.map { |p| p["path"] }
+          assert(paths.include?([]))
+        end
+
+        it "has correct problem explanation" do
+          assert(result.problems[0]["explanation"].include?("to be a key, value object"))
+        end
+      end
+
       describe "with extra argument" do
         let(:result) { DairyProductInputType.validate_input({"source" => "COW", "fatContent" => 0.4, "isDelicious" => false}, PermissiveWarden) }
 

data/spec/graphql/query/variables_spec.rb

@@ -13,7 +13,7 @@ describe GraphQL::Query::Variables do
   let(:schema) { DummySchema }
   let(:variables) { GraphQL::Query::Variables.new(
     schema,
-    GraphQL::Schema::Warden.new(schema, GraphQL::Query::NullExcept),
+    GraphQL::Schema::Warden.new(schema.default_mask, schema: schema, context: nil),
     ast_variables,
     provided_variables)
   }

data/spec/graphql/relay/array_connection_spec.rb

@@ -79,6 +79,15 @@ describe GraphQL::Relay::ArrayConnection do
 
       result = star_wars_query(query_string, "before" => last_cursor, "last" => 2)
       assert_equal(["X-Wing", "Y-Wing"], get_names(result))
+
+      result = star_wars_query(query_string, "last" => 2)
+      assert_equal(["Millenium Falcon", "Home One"], get_names(result))
+    end
+
+    it 'handles cursors beyond the bounds of the array' do
+      overreaching_cursor = Base64.strict_encode64("100")
+      result = star_wars_query(query_string, "after" => overreaching_cursor, "first" => 2)
+      assert_equal([], get_names(result))
     end
 
     it 'applies custom arguments' do

data/spec/graphql/relay/connection_type_spec.rb

@@ -36,5 +36,25 @@ describe GraphQL::Relay::ConnectionType do
         assert_equal [upcased_rebels_name] , bases["edges"].map { |e| e["upcasedParentName"] }.uniq
       end
     end
+
+    describe "connections with nodes field" do
+      let(:query_string) {%|
+        {
+          rebels {
+            bases: basesWithCustomEdge {
+              nodes {
+                name
+              }
+            }
+          }
+        }
+      |}
+
+      it "uses the custom edge and custom connection" do
+        result = star_wars_query(query_string)
+        bases = result["data"]["rebels"]["bases"]
+        assert_equal ["Yavin", "Echo Base", "Secret Hideout"] , bases["nodes"].map { |e| e["name"] }
+      end
+    end
   end
 end

data/spec/graphql/relay/node_spec.rb

@@ -2,6 +2,12 @@
 require "spec_helper"
 
 describe GraphQL::Relay::Node do
+  describe ".interface" do
+    it "is a default relay type" do
+      assert_equal true, GraphQL::Relay::Node.interface.default_relay?
+    end
+  end
+
   describe ".field" do
     describe "Custom global IDs" do
       before do