graphql 0.15.3 → 0.16.0

data/lib/graphql/static_validation/all_rules.rb

@@ -23,7 +23,6 @@ module GraphQL
       GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped,
       GraphQL::StaticValidation::VariablesAreUsedAndDefined,
       GraphQL::StaticValidation::VariableUsagesAreAllowed,
-      GraphQL::StaticValidation::DocumentDoesNotExceedMaxDepth,
     ]
   end
 end

data/lib/graphql/static_validation/type_stack.rb

@@ -89,18 +89,14 @@ module GraphQL
         def push(stack, node)
           parent_type = stack.object_types.last
           parent_type = parent_type.unwrap
-          if parent_type.kind.fields?
-            field_class = stack.schema.get_field(parent_type, node.name)
-            stack.field_definitions.push(field_class)
-            if !field_class.nil?
-              next_object_type = field_class.type
-              stack.object_types.push(next_object_type)
-            else
-              stack.object_types.push(nil)
-            end
+
+          field_definition = stack.schema.get_field(parent_type, node.name)
+          stack.field_definitions.push(field_definition)
+          if !field_definition.nil?
+            next_object_type = field_definition.type
+            stack.object_types.push(next_object_type)
           else
-            stack.field_definitions.push(nil)
-            stack.object_types.push(parent_type)
+            stack.object_types.push(nil)
           end
         end
 

data/lib/graphql/static_validation/validation_context.rb

@@ -29,7 +29,7 @@ module GraphQL
         end
 
         @errors = []
-        @visitor = GraphQL::Language::Visitor.new
+        @visitor = GraphQL::Language::Visitor.new(document)
         @type_stack = GraphQL::StaticValidation::TypeStack.new(schema, visitor)
       end
 
@@ -37,6 +37,16 @@ module GraphQL
         @type_stack.object_types
       end
 
+      # @return [GraphQL::BaseType] The current object type
+      def type_definition
+        object_types.last
+      end
+
+      # @return [GraphQL::BaseType] The type which the current type came from
+      def parent_type_definition
+        object_types[-2]
+      end
+
       # @return [GraphQL::Field, nil] The most-recently-entered GraphQL::Field, if currently inside one
       def field_definition
         @type_stack.field_definitions.last

data/lib/graphql/static_validation/validator.rb

@@ -17,16 +17,26 @@ module GraphQL
         @rules = rules
       end
 
-      # Validate `document` against the schema. Returns an array of message hashes.
-      # @param document [GraphQL::Language::Nodes::Document]
+      # Validate `query` against the schema. Returns an array of message hashes.
+      # @param query [GraphQL::Query]
       # @return [Array<Hash>]
       def validate(query)
         context = GraphQL::StaticValidation::ValidationContext.new(query)
+        rewrite = GraphQL::InternalRepresentation::Rewrite.new
+
+        # Put this first so its enters and exits are always called
+        rewrite.validate(context)
         @rules.each do |rules|
           rules.new.validate(context)
         end
-        context.visitor.visit(query.document)
-        context.errors.map(&:to_h)
+
+        context.visitor.visit
+
+        {
+          errors: context.errors.map(&:to_h),
+          # If there were errors, the irep is garbage
+          irep: context.errors.none? ? rewrite.operations : nil,
+        }
       end
     end
   end

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.15.3"
+  VERSION = "0.16.0"
 end

data/readme.md

@@ -13,6 +13,9 @@ A Ruby implementation of [GraphQL](http://graphql.org/).
      - [Defining Your Schema](http://www.rubydoc.info/github/rmosolgo/graphql-ruby/file/guides/defining_your_schema.md)
      - [Executing Queries](http://www.rubydoc.info/github/rmosolgo/graphql-ruby/file/guides/executing_queries.md)
      - [Testing](http://www.rubydoc.info/github/rmosolgo/graphql-ruby/file/guides/testing.md)
+     - [Code Reuse](http://www.rubydoc.info/github/rmosolgo/graphql-ruby/file/guides/code_reuse.md)
+     - [Security](http://www.rubydoc.info/github/rmosolgo/graphql-ruby/file/guides/security.md)
+
 
  - [API Documentation](http://www.rubydoc.info/github/rmosolgo/graphql-ruby)
 
@@ -119,16 +122,14 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
 
 ## To Do
 
-- __1.0 items:__
-  - Non-nulls should _propagate_ to the next non-null field (all the way up to data, if need be)
-- Add docs for shared behaviors & DRY code
-- Subscriptions
-  - Is there something to do at the graphql-ruby level to make this easier for specific implementations?
 - Accept type name as `type` argument?
   - Goal: accept `field :post, "Post"` to look up a type named `"Post"` in the schema
   - Problem: how does a field know which schema to look up the name from?
   - Problem: how can we load types in Rails without accessing the constant?
-- Customizable complexity validator
-  - Types / fields can define their "weight" in a query
-  - Queries can be executed with a "max weight", or Schema can have a default
-  - During validation, we make sure the query doesn't exceed "max weight"
+  - Maybe support by third-party library? `type("Post!")` could implement "type_missing", keeps `graphql-ruby` very simple
+- If we eval'd `define { ... }` blocks _lazily_, would that work around all circular dependency issues?
+- `QueryComplexity` improvements:
+  - Better detection of union / interface possibilities? Right now they're summed
+- Type check improvements:
+  - Use catch-all type/field/argument definitions instead of terminating traversal
+  - Reduce ad-hoc traversals?

data/spec/graphql/analysis/analyze_query_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+describe GraphQL::Analysis do
+  class TypeCollector
+    def initial_value(query)
+      []
+    end
+
+    def call(memo, visit_type, irep_node)
+      if visit_type == :enter
+        memo + [irep_node.return_type]
+      else
+        memo
+      end
+    end
+  end
+
+  describe ".analyze_query" do
+    let(:node_counter) {
+      -> (memo, visit_type, irep_node) {
+        memo ||= Hash.new { |h,k| h[k] = 0 }
+        visit_type == :enter && memo[irep_node.ast_node.class] += 1
+        memo
+      }
+    }
+    let(:type_collector) { TypeCollector.new }
+    let(:analyzers) { [type_collector, node_counter] }
+    let(:reduce_result) { GraphQL::Analysis.analyze_query(query, analyzers) }
+    let(:query) { GraphQL::Query.new(DummySchema, query_string) }
+    let(:query_string) {%|
+      {
+        cheese(id: 1) {
+          id
+          flavor
+        }
+      }
+    |}
+
+    it "calls the defined analyzers" do
+      collected_types, node_counts = reduce_result
+      expected_visited_types = [QueryType, CheeseType, GraphQL::INT_TYPE, GraphQL::STRING_TYPE]
+      assert_equal expected_visited_types, collected_types
+      expected_node_counts = {
+        GraphQL::Language::Nodes::OperationDefinition => 1,
+        GraphQL::Language::Nodes::Field => 3,
+      }
+      assert_equal expected_node_counts, node_counts
+    end
+  end
+end

data/spec/graphql/analysis/max_query_complexity_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+describe GraphQL::Analysis::MaxQueryComplexity do
+  before do
+    @prev_max_complexity = DummySchema.max_complexity
+  end
+
+  after do
+    DummySchema.max_complexity = @prev_max_complexity
+  end
+
+
+  let(:result) { DummySchema.execute(query_string) }
+  let(:query_string) {%|
+    {
+      a: cheese(id: 1) { id }
+      b: cheese(id: 1) { id }
+      c: cheese(id: 1) { id }
+      d: cheese(id: 1) { id }
+      e: cheese(id: 1) { id }
+    }
+  |}
+
+  describe "when a query goes over max complexity" do
+    before do
+      DummySchema.max_complexity = 9
+    end
+
+    it "returns an error" do
+      assert_equal "Query has complexity of 10, which exceeds max complexity of 9", result["errors"][0]["message"]
+    end
+  end
+
+  describe "when there is no max complexity" do
+    before do
+      DummySchema.max_complexity = nil
+    end
+    it "doesn't error" do
+      assert_equal nil, result["errors"]
+    end
+  end
+
+  describe "when the query is less than the max complexity" do
+    before do
+      DummySchema.max_complexity = 99
+    end
+    it "doesn't error" do
+      assert_equal nil, result["errors"]
+    end
+  end
+
+  describe "when complexity is overriden at query-level" do
+    before do
+      DummySchema.max_complexity = 100
+    end
+    let(:result) { DummySchema.execute(query_string, max_complexity: 7) }
+
+    it "is applied" do
+      assert_equal "Query has complexity of 10, which exceeds max complexity of 7", result["errors"][0]["message"]
+    end
+  end
+end

data/spec/graphql/{static_validation/rules/document_does_not_exceed_max_depth_spec.rb → analysis/max_query_depth_spec.rb}

@@ -1,11 +1,15 @@
 require "spec_helper"
 
-describe GraphQL::StaticValidation::DocumentDoesNotExceedMaxDepth do
-  let(:rule) { GraphQL::StaticValidation::DocumentDoesNotExceedMaxDepth }
-  let(:validator) { GraphQL::StaticValidation::Validator.new(schema: DummySchema, rules: [rule]) }
-  let(:query) { GraphQL::Query.new(DummySchema, query_string) }
-  let(:errors) { validator.validate(query) }
+describe GraphQL::Analysis::MaxQueryDepth do
+  before do
+    @prev_max_depth = DummySchema.max_depth
+  end
+
+  after do
+    DummySchema.max_depth = @prev_max_depth
+  end
 
+  let(:result) { DummySchema.execute(query_string) }
   let(:query_string) { "
     {
       cheese(id: 1) {
@@ -26,48 +30,43 @@ describe GraphQL::StaticValidation::DocumentDoesNotExceedMaxDepth do
 
   describe "when the query is deeper than max depth" do
     it "adds an error message for a too-deep query" do
-      assert_equal 1, errors.length
+      assert_equal "Query has depth of 7, which exceeds max depth of 5", result["errors"][0]["message"]
     end
   end
 
   describe "when the query specifies a different max_depth" do
-    let(:query) { GraphQL::Query.new(DummySchema, query_string, max_depth: 100) }
+    let(:result) { DummySchema.execute(query_string, max_depth: 100) }
+
     it "obeys that max_depth" do
-      assert_equal 0, errors.length
+      assert_equal nil, result["errors"]
     end
   end
 
   describe "When the query is not deeper than max_depth" do
     before do
-      @prev_max_depth = DummySchema.max_depth
       DummySchema.max_depth = 100
     end
 
-    after do
-      DummySchema.max_depth = @prev_max_depth
-    end
-
     it "doesn't add an error" do
-      assert_equal 0, errors.length
+      assert_equal nil, result["errors"]
     end
   end
 
   describe "when the max depth isn't set" do
     before do
-      @prev_max_depth = DummySchema.max_depth
       DummySchema.max_depth = nil
     end
 
-    after do
-      DummySchema.max_depth = @prev_max_depth
-    end
-
     it "doesn't add an error message" do
-      assert_equal 0, errors.length
+      assert_equal nil, result["errors"]
     end
   end
 
   describe "when a fragment exceeds max depth" do
+    before do
+      DummySchema.max_depth = 4
+    end
+
     let(:query_string) { "
       {
         cheese(id: 1) {
@@ -95,7 +94,7 @@ describe GraphQL::StaticValidation::DocumentDoesNotExceedMaxDepth do
     "}
 
     it "adds an error message for a too-deep query" do
-      assert_equal 1, errors.length
+      assert_equal 1, result["errors"].length
     end
   end
 end

data/spec/graphql/analysis/query_complexity_spec.rb

@@ -0,0 +1,235 @@
+require "spec_helper"
+
+describe GraphQL::Analysis::QueryComplexity do
+  let(:complexities) { [] }
+  let(:query_complexity) { GraphQL::Analysis::QueryComplexity.new { |this_query, complexity|  complexities << this_query << complexity } }
+  let(:reduce_result) { GraphQL::Analysis.analyze_query(query, [query_complexity]) }
+  let(:variables) { {} }
+  let(:query) { GraphQL::Query.new(DummySchema, query_string, variables: variables) }
+
+  describe "simple queries" do
+    let(:query_string) {%|
+      query cheeses($isSkipped: Boolean = false){
+        # complexity of 3
+        cheese1: cheese(id: 1) {
+          id
+          flavor
+        }
+
+        # complexity of 4
+        cheese2: cheese(id: 2) @skip(if: $isSkipped) {
+          similarCheese(source: SHEEP) {
+            ... on Cheese {
+              similarCheese(source: SHEEP) {
+                id
+              }
+            }
+          }
+        }
+      }
+    |}
+
+    it "sums the complexity" do
+      reduce_result
+      assert_equal complexities, [query, 7]
+    end
+
+    describe "when skipped by directives" do
+      let(:variables) { { "isSkipped" => true } }
+      it "doesn't include skipped fields" do
+        reduce_result
+        assert_equal complexities, [query, 3]
+      end
+    end
+  end
+
+  describe "query with fragments" do
+    let(:query_string) {%|
+      {
+        # complexity of 3
+        cheese1: cheese(id: 1) {
+          id
+          flavor
+        }
+
+        # complexity of 7
+        cheese2: cheese(id: 2) {
+          ... cheeseFields1
+          ... cheeseFields2
+        }
+      }
+
+      fragment cheeseFields1 on Cheese {
+        similarCow: similarCheese(source: COW) {
+          id
+          ... cheeseFields2
+        }
+      }
+
+      fragment cheeseFields2 on Cheese {
+        similarSheep: similarCheese(source: SHEEP) {
+          id
+        }
+      }
+    |}
+
+    it "counts all fragment usages, not the definitions" do
+      reduce_result
+      assert_equal complexities, [query, 10]
+    end
+
+    describe "mutually exclusive types" do
+      let(:query_string) {%|
+        {
+          favoriteEdible {
+            # 1 for everybody
+            fatContent
+
+            # 1 for everybody
+            ... on Edible {
+              origin
+            }
+
+            # 1 for honey
+            ... on Sweetener {
+              sweetness
+            }
+
+            # 2 for milk
+            ... milkFields
+            # 1 for cheese
+            ... cheeseFields
+            # 1 for honey
+            ... honeyFields
+            # 1 for milk + cheese
+            ... dairyProductFields
+          }
+        }
+
+        fragment milkFields on Milk {
+          id
+          source
+        }
+
+        fragment cheeseFields on Cheese {
+          source
+        }
+
+        fragment honeyFields on Honey {
+          flowerType
+        }
+
+        fragment dairyProductFields on DairyProduct {
+          ... on Cheese {
+            flavor
+          }
+
+          ... on Milk {
+            flavors
+          }
+        }
+      |}
+
+      it "gets the max among options" do
+        reduce_result
+        assert_equal 5, complexities.last
+      end
+    end
+
+
+    describe "when there are no selections on any object types" do
+      let(:query_string) {%|
+        {
+          favoriteEdible {
+            # 1 for everybody
+            fatContent
+
+            # 1 for everybody
+            ... on Edible { origin }
+
+            # 1 for honey
+            ... on Sweetener { sweetness }
+          }
+        }
+      |}
+
+      it "gets the max among interface types" do
+        reduce_result
+        assert_equal 3, complexities.last
+      end
+    end
+
+    describe "redundant fields" do
+      let(:query_string) {%|
+      {
+        favoriteEdible {
+          fatContent
+          # this is executed separately and counts separately:
+          aliasedFatContent: fatContent
+
+          ... on Edible {
+            fatContent
+          }
+
+          ... edibleFields
+        }
+      }
+
+      fragment edibleFields on Edible {
+        fatContent
+      }
+      |}
+
+      it "only counts them once" do
+        reduce_result
+        assert_equal 3, complexities.last
+      end
+    end
+  end
+
+
+  describe "custom complexities" do
+    let(:query) { GraphQL::Query.new(complexity_schema, query_string) }
+    let(:complexity_schema) {
+      complexity_type = GraphQL::ObjectType.define do
+        name "Complexity"
+        field :value, types.Int, complexity: 0.1 do
+          resolve -> (obj, args, ctx) { obj }
+        end
+        field :complexity, -> { complexity_type } do
+          argument :value, types.Int
+          complexity -> (ctx, args, child_complexity) { args[:value] + child_complexity }
+          resolve -> (obj, args, ctx) { args[:value] }
+        end
+      end
+
+      query_type = GraphQL::ObjectType.define do
+        name "Query"
+        field :complexity, -> { complexity_type } do
+          argument :value, types.Int
+          complexity -> (ctx, args, child_complexity) { args[:value] + child_complexity }
+          resolve -> (obj, args, ctx) { args[:value] }
+        end
+      end
+
+      GraphQL::Schema.new(query: query_type)
+    }
+    let(:query_string) {%|
+      {
+        a: complexity(value: 3) { value }
+        b: complexity(value: 6) {
+          value
+          complexity(value: 1) {
+            value
+          }
+        }
+      }
+    |}
+
+    it "sums the complexity" do
+      reduce_result
+      # 10 from `complexity`, `0.3` from `value`
+      assert_equal complexities, [query, 10.3]
+    end
+  end
+end