graphql 1.9.0 → 2.1.1

data/spec/fixtures/upgrader/photo.transformed.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-module Platform
-  module Objects
-    class Photo < Platform::Objects::Base
-      field :caption, String, null: true
-
-      def caption
-        object.caption
-      end
-    end
-  end
-end

data/spec/fixtures/upgrader/release_order.original.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Platform
-  module Inputs
-    ReleaseOrder = GraphQL::InputObjectType.define do
-      name "ReleaseOrder"
-      description "Ways in which lists of releases can be ordered upon return."
-
-      input_field :field, types[!Enums::ReleaseOrderField], <<-MD
-        The field in which to order releases by.
-      MD
-      input_field :direction, !Enums::OrderDirection, "The direction in which to order releases by the specified field."
-    end
-  end
-end

data/spec/fixtures/upgrader/release_order.transformed.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Platform
-  module Inputs
-    class ReleaseOrder < Platform::Inputs::Base
-      description "Ways in which lists of releases can be ordered upon return."
-
-      argument :field, [Enums::ReleaseOrderField], <<-MD, required: false
-        The field in which to order releases by.
-      MD
-      argument :direction, Enums::OrderDirection, "The direction in which to order releases by the specified field.", required: true
-    end
-  end
-end

data/spec/fixtures/upgrader/starrable.original.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Platform
-  module Interfaces
-    Starrable = GraphQL::InterfaceType.define do
-      name "Starrable"
-      description "Things that can be starred."
-
-      global_id_field :id
-
-      field :viewerHasStarred, !types.Boolean do
-        argument :preceedsConnectionMethod, types.Boolean
-        description "Returns a boolean indicating whether the viewing user has starred this starrable."
-
-        resolve ->(object, arguments, context) do
-          if context[:viewer]
-            ->(test_inner_proc) do
-              context[:viewer].starred?(object)
-            end
-          else
-            false
-          end
-        end
-      end
-
-      connection :stargazers, -> { !Connections::Stargazer } do
-        description "A list of users who have starred this starrable."
-
-        argument :orderBy, Inputs::StarOrder, "Order for connection"
-
-        resolve ->(object, arguments, context) do
-          scope = case object
-          when Repository
-            object.stars
-          when Gist
-            GistStar.where(gist_id: object.id)
-          end
-
-          table = scope.table_name
-          if order_by = arguments["orderBy"]
-            scope = scope.order("#{table}.#{order_by["field"]} #{order_by["direction"]}")
-          end
-
-          scope
-        end
-      end
-    end
-  end
-end

data/spec/fixtures/upgrader/starrable.transformed.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Platform
-  module Interfaces
-    module Starrable
-      include Platform::Interfaces::Base
-      description "Things that can be starred."
-
-      global_id_field :id
-
-      field :viewer_has_starred, Boolean, description: "Returns a boolean indicating whether the viewing user has starred this starrable.", null: false do
-        argument :preceeds_connection_method, Boolean, required: false
-      end
-
-      def viewer_has_starred(**arguments)
-        if context[:viewer]
-          ->(test_inner_proc) do
-            context[:viewer].starred?(object)
-          end
-        else
-          false
-        end
-      end
-
-      field :stargazers, Connections::Stargazer, description: "A list of users who have starred this starrable.", null: false, connection: true do
-        argument :order_by, Inputs::StarOrder, "Order for connection", required: false
-      end
-
-      def stargazers(**arguments)
-        scope = case object
-        when Repository
-          object.stars
-        when Gist
-          GistStar.where(gist_id: object.id)
-        end
-
-        table = scope.table_name
-        if order_by = arguments[:order_by]
-          scope = scope.order("#{table}.#{order_by["field"]} #{order_by["direction"]}")
-        end
-
-        scope
-      end
-    end
-  end
-end

data/spec/fixtures/upgrader/subscribable.original.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Platform
-  module Interfaces
-    Subscribable = GraphQL::InterfaceType.define do
-      name "Subscribable"
-      description "Entities that can be subscribed to for web and email notifications."
-
-      field :id, !GraphQL::ID_TYPE, property: :global_relay_id
-
-      field :viewerSubscription, -> { !Enums::SubscriptionState } do
-        description "Identifies if the viewer is watching, not watching, or ignoring the subscribable entity."
-
-        resolve ->(subscribable, arguments, context) do
-          if context[:viewer].nil?
-            return "unsubscribed"
-          end
-
-          subscription_status_response = subscribable.async_subscription_status(context[:viewer]).sync
-
-          if subscription_status_response.failed?
-            error = Platform::Errors::ServiceUnavailable.new("Subscriptions are currently unavailable. Please try again later.")
-            error.ast_node = context.irep_node.ast_node
-            error.path = context.path
-            context.errors << error
-            return "unavailable"
-          end
-
-          subscription = subscription_status_response.value
-          if subscription.included?
-            "unsubscribed"
-          elsif subscription.subscribed?
-            "subscribed"
-          elsif subscription.ignored?
-            "ignored"
-          end
-        end
-      end
-
-      field :viewerCanSubscribe, !types.Boolean do
-        description "Check if the viewer is able to change their subscription status for the repository."
-
-        resolve ->(subscribable, arguments, context) do
-          return false if context[:viewer].nil?
-
-          subscribable.async_subscription_status(context[:viewer]).then(&:success?)
-        end
-      end
-
-      connection :issues, function: Platform::Functions::Issues.new, description: "A list of issues associated with the milestone."
-      connection :files, -> { !Connections.define(PackageFile) }, description: "List of files associated with this registry package version"
-      field :enabled, !types.Boolean, "Whether enabled for this project", property: :enabled?
-    end
-  end
-end

data/spec/fixtures/upgrader/subscribable.transformed.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Platform
-  module Interfaces
-    module Subscribable
-      include Platform::Interfaces::Base
-      description "Entities that can be subscribed to for web and email notifications."
-
-      field :id, GraphQL::ID_TYPE, method: :global_relay_id, null: false
-
-      field :viewer_subscription, Enums::SubscriptionState, description: "Identifies if the viewer is watching, not watching, or ignoring the subscribable entity.", null: false
-
-      def viewer_subscription
-        if context[:viewer].nil?
-          return "unsubscribed"
-        end
-
-        subscription_status_response = object.async_subscription_status(context[:viewer]).sync
-
-        if subscription_status_response.failed?
-          error = Platform::Errors::ServiceUnavailable.new("Subscriptions are currently unavailable. Please try again later.")
-          error.ast_node = context.irep_node.ast_node
-          error.path = context.path
-          context.errors << error
-          return "unavailable"
-        end
-
-        subscription = subscription_status_response.value
-        if subscription.included?
-          "unsubscribed"
-        elsif subscription.subscribed?
-          "subscribed"
-        elsif subscription.ignored?
-          "ignored"
-        end
-      end
-
-      field :viewer_can_subscribe, Boolean, description: "Check if the viewer is able to change their subscription status for the repository.", null: false
-
-      def viewer_can_subscribe
-        return false if context[:viewer].nil?
-
-        object.async_subscription_status(context[:viewer]).then(&:success?)
-      end
-
-      field :issues, function: Platform::Functions::Issues.new, description: "A list of issues associated with the milestone.", connection: true
-      field :files, Connections.define(PackageFile), description: "List of files associated with this registry package version", null: false, connection: true
-      field :enabled, Boolean, "Whether enabled for this project", method: :enabled?, null: false
-    end
-  end
-end

data/spec/fixtures/upgrader/type_x.original.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module Platform
-  module Objects
-    X = define_active_record_type(-> { ::X }) do
-      name "X"
-      description "An x on a y."
-      visibility :internal
-      minimum_accepted_scopes ["z"]
-
-      global_id_field :id
-      interfaces [GraphQL::Relay::Node.interface]
-
-      field :f1,    !Objects::O1, "The x being y."
-      field :f2,    !Enums::E1, "x for the y.",
-        property: :field_2
-      field :f3, Enums::E2, "x for y."
-      field :details, types.String, "Details."
-
-      field :f4, !Objects::O2, "x as a y inside the z." do
-        argument :a1, !Inputs::I1
-
-        resolve ->(obj_x, arguments, context) do
-          Class1.new(
-            a: Class2.new(
-              b: obj_x.b_1,
-              c: obj_x.c_1
-            ),
-            d: Class3.new(
-              b: obj_x.b_2,
-              c: obj_x.c_3,
-            )
-          )
-        end
-      end
-
-      field :f5, -> { !types.String } do
-        description "The thing"
-        property :custom_property
-        visibility :custom_value
-      end
-
-      field :f6, -> { !types.String } do
-        description "The thing"
-        property :custom_property
-        visibility :custom_value
-      end
-
-      field :f7, field: SomeField
-      field :f8, function: SomeFunction
-      field :f9, types[Objects::O2]
-      field :fieldField, types.String, hash_key: "fieldField"
-      field :fieldField2, types.String, property: :field_field2
-
-      field :f10, types.String do
-        resolve ->(obj, _, _) do
-          obj.something do |_|
-            xyz_obj.obj
-            obj.f10
-          end
-        end
-      end
-    end
-  end
-end

data/spec/fixtures/upgrader/type_x.transformed.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module Platform
-  module Objects
-    class X < Platform::Objects::Base
-      model_name "X"
-      description "An x on a y."
-      visibility :internal
-      minimum_accepted_scopes ["z"]
-
-      global_id_field :id
-      implements GraphQL::Relay::Node.interface
-
-      field :f1, Objects::O1, "The x being y.", null: false
-      field :f2, Enums::E1, "x for the y.", method: :field_2, null: false
-      field :f3, Enums::E2, "x for y.", null: true
-      field :details, String, "Details.", null: true
-
-      field :f4, Objects::O2, "x as a y inside the z.", null: false do
-        argument :a1, Inputs::I1, required: true
-      end
-
-      def f4(**arguments)
-        Class1.new(
-          a: Class2.new(
-            b: object.b_1,
-            c: object.c_1
-          ),
-          d: Class3.new(
-            b: object.b_2,
-            c: object.c_3,
-          )
-        )
-      end
-
-      field :f5, String, visibility: :custom_value, method: :custom_property, description: "The thing", null: false
-
-      field :f6, String, visibility: :custom_value, method: :custom_property, description: "The thing", null: false
-
-      field :f7, field: SomeField
-      field :f8, function: SomeFunction
-      field :f9, [Objects::O2, null: true], null: true
-      field :field_field, String, hash_key: "fieldField", null: true
-      field :field_field2, String, null: true
-
-      field :f10, String, null: true
-
-      def f10
-        object.something do |_|
-          xyz_obj.obj
-          object.f10
-        end
-      end
-    end
-  end
-end

data/spec/graphql/analysis/analyze_query_spec.rb

@@ -1,272 +0,0 @@
-# frozen_string_literal: true
-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.unwrap]
-      else
-        memo
-      end
-    end
-  end
-
-  class ConditionalAnalyzer
-    def analyze?(query)
-      !!query.context[:analyze]
-    end
-
-    def initial_value(query)
-      {}
-    end
-
-    def call(memo, visit_type, irep_node)
-      memo[:i_have_been_called] ||= true
-      memo
-    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(:variables) { {} }
-    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables) }
-    let(:query_string) {%|
-      {
-        cheese(id: 1) {
-          id
-          flavor
-        }
-      }
-    |}
-
-    describe "conditional analysis" do
-      let(:conditional_analyzer) { ConditionalAnalyzer.new }
-      let(:analyzers) { [type_collector, conditional_analyzer] }
-
-      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
-    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,
-      }
-      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
-
-    describe "when a variable is missing" do
-      let(:query_string) {%|
-        query something($cheeseId: Int!){
-          cheese(id: $cheeseId) {
-            id
-            flavor
-          }
-        }
-      |}
-      let(:variable_accessor) { ->(memo, visit_type, irep_node) { query.variables["cheeseId"] } }
-
-      before do
-        @previous_query_analyzers = Dummy::Schema.query_analyzers.dup
-        Dummy::Schema.query_analyzers.clear
-        Dummy::Schema.query_analyzers << variable_accessor
-      end
-
-      after do
-        Dummy::Schema.query_analyzers.clear
-        Dummy::Schema.query_analyzers.push(*@previous_query_analyzers)
-      end
-
-      it "returns an error" do
-        error = query.result["errors"].first
-        assert_equal "Variable cheeseId of type Int! was provided invalid value", error["message"]
-      end
-    end
-
-    describe "when processing fields" do
-      let(:connection_counter) {
-        ->(memo, visit_type, irep_node) {
-          memo ||= Hash.new { |h,k| h[k] = 0 }
-          if visit_type == :enter
-            if irep_node.ast_node.is_a?(GraphQL::Language::Nodes::Field)
-              if irep_node.definition.connection?
-                memo[:connection] ||= 0
-                memo[:connection] += 1
-              else
-                memo[:field] ||= 0
-                memo[:field] += 1
-              end
-            end
-          end
-          memo
-        }
-      }
-      let(:analyzers) { [connection_counter] }
-      let(:reduce_result) { GraphQL::Analysis.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 = {
-          :field => 5,
-          :connection => 2
-        }
-        assert_equal expected_connection_counts, connection_counts
-      end
-    end
-  end
-
-  describe ".visit_analyzers" do
-    class IdCatcher
-      def call(memo, visit_type, irep_node)
-        if visit_type == :enter
-          if irep_node.ast_node.name == "id"
-            raise GraphQL::AnalysisError.new("Don't use the id field.", ast_node: irep_node.ast_node)
-          end
-        end
-        memo
-      end
-    end
-
-    class FlavorCatcher
-      def initial_value(query)
-        {
-          :errors => []
-        }
-      end
-
-      def call(memo, visit_type, irep_node)
-        if visit_type == :enter
-          if irep_node.ast_node.name == "flavor"
-            memo[:errors] << GraphQL::AnalysisError.new("Don't use the flavor field.", ast_node: irep_node.ast_node)
-          end
-        end
-        memo
-      end
-
-      def final_value(memo)
-        memo[:errors]
-      end
-    end
-
-    let(:id_catcher) { IdCatcher.new }
-    let(:flavor_catcher) { FlavorCatcher.new }
-    let(:analyzers) { [id_catcher, flavor_catcher] }
-    let(:reduce_result) { GraphQL::Analysis.analyze_query(query, analyzers) }
-    let(:query) { GraphQL::Query.new(Dummy::Schema, query_string) }
-    let(:query_string) {%|
-      {
-        cheese(id: 1) {
-          id
-          flavor
-        }
-      }
-    |}
-    let(:schema) { Dummy::Schema }
-    let(:result) { schema.execute(query_string) }
-    let(:query_string) {%|
-      {
-        cheese(id: 1) {
-          id
-          flavor
-        }
-      }
-    |}
-
-    before do
-      @previous_query_analyzers = Dummy::Schema.query_analyzers.dup
-      Dummy::Schema.query_analyzers.clear
-      Dummy::Schema.query_analyzers << id_catcher << flavor_catcher
-    end
-
-    after do
-      Dummy::Schema.query_analyzers.clear
-      Dummy::Schema.query_analyzers.push(*@previous_query_analyzers)
-    end
-
-    it "groups all errors together" do
-      data = result["data"]
-      errors = result["errors"]
-
-      id_error_hash = errors[0]
-      flavor_error_hash = errors[1]
-
-      id_error_response = {
-        "message"=>"Don't use the id field.",
-        "locations"=>[{"line"=>4, "column"=>11}]
-      }
-      flavor_error_response = {
-        "message"=>"Don't use the flavor field.",
-        "locations"=>[{"line"=>5, "column"=>11}]
-      }
-
-      assert_nil data
-
-      assert_equal id_error_response["message"], id_error_hash["message"]
-      assert_equal id_error_response["locations"], id_error_hash["locations"]
-
-      assert_equal flavor_error_response["message"], flavor_error_hash["message"]
-      assert_equal flavor_error_response["locations"], flavor_error_hash["locations"]
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Analysis::AST::FieldUsage do
-  let(:result) { GraphQL::Analysis::AST.analyze_query(query, [GraphQL::Analysis::AST::FieldUsage]).first }
-  let(:query) { GraphQL::Query.new(Dummy::Schema, query_string, variables: variables) }
-  let(:variables) { {} }
-
-  describe "query with deprecated fields" do
-    let(:query_string) {%|
-      query {
-        cheese(id: 1) {
-          id
-          fatContent
-        }
-      }
-    |}
-
-    it "keeps track of used fields" do
-      assert_equal ['Cheese.id', 'Cheese.fatContent', 'Query.cheese'], result[:used_fields]
-    end
-
-    it "keeps track of deprecated fields" do
-      assert_equal ['Cheese.fatContent'], result[:used_deprecated_fields]
-    end
-  end
-
-  describe "query with deprecated fields used more than once" do
-    let(:query_string) {%|
-      query {
-        cheese1: cheese(id: 1) {
-          id
-          fatContent
-        }
-
-        cheese2: cheese(id: 2) {
-          id
-          fatContent
-        }
-      }
-    |}
-
-    it "omits duplicate usage of a field" do
-      assert_equal ['Cheese.id', 'Cheese.fatContent', 'Query.cheese'], result[:used_fields]
-    end
-
-    it "omits duplicate usage of a deprecated field" do
-      assert_equal ['Cheese.fatContent'], result[:used_deprecated_fields]
-    end
-  end
-end