graphql 1.8.7 → 1.9.0

data/spec/graphql/analysis/ast/query_complexity_spec.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Analysis::AST::QueryComplexity do
+  let(:reduce_result) { GraphQL::Analysis::AST.analyze_query(query, [GraphQL::Analysis::AST::QueryComplexity]) }
+  let(:variables) { {} }
+  let(:query) { GraphQL::Query.new(Dummy::Schema, 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
+      complexities = reduce_result.first
+      assert_equal 7, complexities
+    end
+
+    describe "when skipped by directives" do
+      let(:variables) { { "isSkipped" => true } }
+      it "doesn't include skipped fields" do
+        complexity = reduce_result.first
+        assert_equal 3, complexity
+      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
+      complexity = reduce_result.first
+      assert_equal 10, complexity
+    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
+        complexity = reduce_result.first
+        assert_equal 6, complexity
+      end
+    end
+
+
+    describe "when there are no selections on any object types" do
+      let(:query_string) {%|
+        {
+          # 1 for everybody
+          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
+        complexity = reduce_result.first
+        assert_equal 4, complexity
+      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
+        complexity = reduce_result.first
+        assert_equal 3, complexity
+      end
+    end
+  end
+
+  describe "relay types" do
+    let(:query) { GraphQL::Query.new(StarWars::Schema, query_string) }
+    let(:query_string) {%|
+    {
+      rebels {
+        ships {
+          edges {
+            node {
+              id
+            }
+          }
+          pageInfo {
+            hasNextPage
+          }
+        }
+      }
+    }
+    |}
+
+    it "gets the complexity" do
+      complexity = reduce_result.first
+      assert_equal 7, complexity
+    end
+  end
+
+  describe "custom complexities" do
+    let(:query) { GraphQL::Query.new(complexity_schema, query_string) }
+    let(:complexity_schema) {
+      complexity_interface = GraphQL::InterfaceType.define do
+        name "ComplexityInterface"
+        field :value, types.Int
+      end
+
+      single_complexity_type = GraphQL::ObjectType.define do
+        name "SingleComplexity"
+        field :value, types.Int, complexity: 0.1 do
+          resolve ->(obj, args, ctx) { obj }
+        end
+        field :complexity, single_complexity_type do
+          argument :value, types.Int
+          complexity ->(ctx, args, child_complexity) { args[:value] + child_complexity }
+          resolve ->(obj, args, ctx) { args[:value] }
+        end
+        interfaces [complexity_interface]
+      end
+
+      double_complexity_type = GraphQL::ObjectType.define do
+        name "DoubleComplexity"
+        field :value, types.Int, complexity: 4 do
+          resolve ->(obj, args, ctx) { obj }
+        end
+        interfaces [complexity_interface]
+      end
+
+      query_type = GraphQL::ObjectType.define do
+        name "Query"
+        field :complexity, single_complexity_type do
+          argument :value, types.Int
+          complexity ->(ctx, args, child_complexity) { args[:value] + child_complexity }
+          resolve ->(obj, args, ctx) { args[:value] }
+        end
+
+        field :innerComplexity, complexity_interface do
+          argument :value, types.Int
+          resolve ->(obj, args, ctx) { args[:value] }
+        end
+      end
+
+      GraphQL::Schema.define(
+        query: query_type,
+        orphan_types: [double_complexity_type],
+        resolve_type: ->(a,b,c) { :pass }
+      )
+    }
+    let(:query_string) {%|
+      {
+        a: complexity(value: 3) { value }
+        b: complexity(value: 6) {
+          value
+          complexity(value: 1) {
+            value
+          }
+        }
+      }
+    |}
+
+    it "sums the complexity" do
+      complexity = reduce_result.first
+      # 10 from `complexity`, `0.3` from `value`
+      assert_equal 10.3, complexity
+    end
+
+    describe "same field on multiple types" do
+      let(:query_string) {%|
+      {
+        innerComplexity(value: 2) {
+          ... on SingleComplexity { value }
+          ... on DoubleComplexity { value }
+        }
+      }
+      |}
+
+      it "picks them max for those fields" do
+        complexity = reduce_result.first
+        # 1 for innerComplexity + 4 for DoubleComplexity.value
+        assert_equal 5, complexity
+      end
+    end
+  end
+end

data/spec/graphql/analysis/ast/query_depth_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Analysis::AST::QueryDepth do
+  let(:result) { GraphQL::Analysis::AST.analyze_query(query, [GraphQL::Analysis::AST::QueryDepth]) }
+  let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables) }
+  let(:variables) { {} }
+
+  describe "multiple operations" do
+    let(:query_string) {%|
+      query Cheese1 {
+        cheese1: cheese(id: 1) {
+          id
+          flavor
+        }
+      }
+
+      query Cheese2 {
+        cheese(id: 2) {
+          similarCheese(source: SHEEP) {
+            ... on Cheese {
+              similarCheese(source: SHEEP) {
+                id
+              }
+            }
+          }
+        }
+      }
+    |}
+
+    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables, operation_name: "Cheese1") }
+
+    it "analyzes the selected operation only" do
+      depth = result.first
+      assert_equal 2, depth
+    end
+  end
+
+  describe "simple queries" do
+    let(:query_string) {%|
+      query cheeses($isIncluded: Boolean = true){
+        # depth of 2
+        cheese1: cheese(id: 1) {
+          id
+          flavor
+        }
+
+        # depth of 4
+        cheese2: cheese(id: 2) @include(if: $isIncluded) {
+          similarCheese(source: SHEEP) {
+            ... on Cheese {
+              similarCheese(source: SHEEP) {
+                id
+              }
+            }
+          }
+        }
+      }
+    |}
+
+    it "finds the max depth" do
+      depth = result.first
+      assert_equal 4, depth
+    end
+
+    describe "with directives" do
+      let(:variables) { { "isIncluded" => false } }
+
+      it "doesn't count skipped fields" do
+        assert_equal 2, result.first
+      end
+    end
+  end
+
+  describe "query with fragments" do
+    let(:query_string) {%|
+      {
+        # depth of 2
+        cheese1: cheese(id: 1) {
+          id
+          flavor
+        }
+
+        # depth of 4
+        cheese2: cheese(id: 2) {
+          ... cheeseFields1
+        }
+      }
+
+      fragment cheeseFields1 on Cheese {
+        similarCheese(source: COW) {
+          id
+          ... cheeseFields2
+        }
+      }
+
+      fragment cheeseFields2 on Cheese {
+        similarCheese(source: SHEEP) {
+          id
+        }
+      }
+    |}
+
+    it "finds the max depth" do
+      assert_equal 4, result.first
+    end
+  end
+end

data/spec/graphql/analysis/ast_spec.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Analysis::AST do
+  class AstTypeCollector < GraphQL::Analysis::AST::Analyzer
+    def initialize(query)
+      super
+      @types = []
+    end
+
+    def on_enter_operation_definition(node, parent, visitor)
+      @types << visitor.type_definition
+    end
+
+    def on_enter_field(memo, node, visitor)
+      @types << visitor.field_definition.type.unwrap
+    end
+
+    def result
+      @types
+    end
+  end
+
+  class AstNodeCounter < GraphQL::Analysis::AST::Analyzer
+    def initialize(query)
+      super
+      @nodes = Hash.new { |h,k| h[k] = 0 }
+    end
+
+    def on_enter_abstract_node(node, parent, _visitor)
+      @nodes[node.class] += 1
+    end
+
+    def result
+      @nodes
+    end
+  end
+
+  class AstConditionalAnalyzer < GraphQL::Analysis::AST::Analyzer
+    def initialize(query)
+      super
+      @i_have_been_called = false
+    end
+
+    def analyze?
+      !!query.context[:analyze]
+    end
+
+    def on_operation_definition(node, parent, visitor)
+      @i_have_been_called = true
+    end
+
+    def result
+      @i_have_been_called
+    end
+  end
+
+  class AstErrorAnalyzer < GraphQL::Analysis::AST::Analyzer
+    def result
+      GraphQL::AnalysisError.new("An Error!")
+    end
+  end
+
+  class AstPreviousField < GraphQL::Analysis::AST::Analyzer
+    def on_enter_field(node, parent, visitor)
+      @previous_field = visitor.previous_field_definition
+    end
+
+    def result
+      @previous_field
+    end
+  end
+
+  describe "using the AST analysis engine" do
+    let(:schema) do
+      query_type = Class.new(GraphQL::Schema::Object) do
+        graphql_name 'Query'
+
+        field :foobar, Integer, null: false
+
+        def foobar
+          1337
+        end
+      end
+
+      Class.new(GraphQL::Schema) do
+        query query_type
+        use GraphQL::Analysis::AST
+        query_analyzer AstErrorAnalyzer
+        use GraphQL::Execution::Interpreter
+      end
+    end
+
+    let(:query_string) {%|
+      query {
+        foobar
+      }
+    |}
+
+    let(:query) { GraphQL::Query.new(schema, query_string, variables: {}) }
+
+    it "runs the AST analyzers correctly" do
+      res = query.result
+      refute res.key?("data")
+      assert_equal ["An Error!"], res["errors"].map { |e| e["message"] }
+    end
+
+    it "skips rewrite" do
+      # Try running the query:
+      query.result
+      # But the validation step doesn't build an irep_node tree
+      assert_nil query.irep_selection
+    end
+
+    describe "when validate: false" do
+      let(:query) { GraphQL::Query.new(schema, query_string, validate: false) }
+      it "Skips rewrite" do
+        # Try running the query:
+        query.result
+        # But the validation step doesn't build an irep_node tree
+        assert_nil query.irep_selection
+      end
+    end
+  end
+
+  describe ".analyze_query" do
+    let(:analyzers) { [AstTypeCollector, AstNodeCounter] }
+    let(:reduce_result) { GraphQL::Analysis::AST.analyze_query(query, analyzers) }
+    let(:variables) { {} }
+    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables) }
+    let(:query_string) {%|
+      {
+        cheese(id: 1) {
+          id
+          flavor
+        }
+      }
+    |}
+
+    describe "without a selected operation" do
+      let(:query_string) {%|
+        # A comment
+        # And nothing else
+        # Should not break
+      |}
+
+      it "bails early when there is no selected operation to be executed" do
+        assert_equal 2, reduce_result.size
+      end
+    end
+
+    describe "conditional analysis" do
+      let(:analyzers) { [AstTypeCollector, AstConditionalAnalyzer] }
+
+      describe "when analyze? returns false" do
+        let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables, context: { analyze: false }) }
+
+        it "does not run the analyzer" do
+          # Only type_collector ran
+          assert_equal 1, reduce_result.size
+        end
+      end
+
+      describe "when analyze? returns true" do
+        let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables, context: { analyze: true }) }
+
+        it "it runs the analyzer" do
+          # Both analyzers ran
+          assert_equal 2, reduce_result.size
+        end
+      end
+
+      describe "Visitor#previous_field_definition" do
+        let(:analyzers) { [AstPreviousField] }
+        let(:query) { GraphQL::Query.new(Dummy::Schema, "{ __schema { types { name } } }") }
+
+        it "it runs the analyzer" do
+          prev_field = reduce_result.first
+          assert_equal "__Schema.types", prev_field.metadata[:type_class].path
+        end
+      end
+    end
+
+    it "calls the defined analyzers" do
+      collected_types, node_counts = reduce_result
+      expected_visited_types = [
+        Dummy::DairyAppQuery.graphql_definition,
+        Dummy::Cheese.graphql_definition,
+        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,
+        GraphQL::Language::Nodes::Argument => 1
+      }
+
+      assert_equal expected_node_counts, node_counts
+    end
+
+    describe "tracing" do
+      let(:query_string) { "{ t: __typename }"}
+
+      it "emits traces" do
+        traces = TestTracing.with_trace do
+          ctx = { tracers: [TestTracing] }
+          Dummy::Schema.execute(query_string, context: ctx)
+        end
+
+        # The query_trace is on the list _first_ because it finished first
+        _lex, _parse, _validate, query_trace, multiplex_trace, *_rest = traces
+
+        assert_equal "analyze_multiplex", multiplex_trace[:key]
+        assert_instance_of GraphQL::Execution::Multiplex, multiplex_trace[:multiplex]
+
+        assert_equal "analyze_query", query_trace[:key]
+        assert_instance_of GraphQL::Query, query_trace[:query]
+      end
+    end
+
+    class AstConnectionCounter < GraphQL::Analysis::AST::Analyzer
+      def initialize(query)
+        super
+        @fields = 0
+        @connections = 0
+      end
+
+      def on_enter_field(node, parent, visitor)
+        if visitor.field_definition.connection?
+          @connections += 1
+        else
+          @fields += 1
+        end
+      end
+
+      def result
+        {
+          fields: @fields,
+          connections: @connections
+        }
+      end
+    end
+
+    describe "when processing fields" do
+      let(:analyzers) { [AstConnectionCounter] }
+      let(:reduce_result) { GraphQL::Analysis::AST.analyze_query(query, analyzers) }
+      let(:query) { GraphQL::Query.new(StarWars::Schema, query_string, variables: variables) }
+      let(:query_string) {%|
+        query getBases {
+          empire {
+            basesByName(first: 30) { edges { cursor } }
+            bases(first: 30) { edges { cursor } }
+          }
+        }
+      |}
+
+      it "knows which fields are connections" do
+        connection_counts = reduce_result.first
+        expected_connection_counts = {
+          :fields => 5,
+          :connections => 2
+        }
+        assert_equal expected_connection_counts, connection_counts
+      end
+    end
+  end
+end