graphql 1.9.11 → 1.9.12

data/spec/support/lazy_helpers.rb

@@ -1,192 +0,0 @@
-# frozen_string_literal: true
-module LazyHelpers
-  MAGIC_NUMBER_WITH_LAZY_AUTHORIZED_HOOK = 44
-  MAGIC_NUMBER_THAT_RETURNS_NIL = 0
-  MAGIC_NUMBER_THAT_RAISES_ERROR = 13
-  class Wrapper
-    def initialize(item = nil, &block)
-      if block
-        @block = block
-      else
-        @item = item
-      end
-    end
-
-    def item
-      if @block
-        @item = @block.call()
-        @block = nil
-      end
-      @item
-    end
-  end
-
-  class SumAll
-    attr_reader :own_value
-    attr_writer :value
-
-    def initialize(own_value)
-      @own_value = own_value
-      all << self
-    end
-
-    def value
-      @value ||= begin
-        total_value = all.map(&:own_value).reduce(&:+)
-        all.each { |v| v.value = total_value}
-        all.clear
-        total_value
-      end
-      @value
-    end
-
-    def all
-      self.class.all
-    end
-
-    def self.all
-      @all ||= []
-    end
-  end
-
-  class LazySum < GraphQL::Schema::Object
-    field :value, Integer, null: true
-    def value
-      if object == MAGIC_NUMBER_THAT_RAISES_ERROR
-        nil
-      else
-        object
-      end
-    end
-
-    def self.authorized?(obj, ctx)
-      if obj == MAGIC_NUMBER_WITH_LAZY_AUTHORIZED_HOOK
-        Wrapper.new { true }
-      else
-        true
-      end
-    end
-
-    field :nestedSum, LazySum, null: false do
-      argument :value, Integer, required: true
-    end
-
-    def nested_sum(value:)
-      if value == MAGIC_NUMBER_THAT_RAISES_ERROR
-        Wrapper.new(nil)
-      else
-        SumAll.new(@object + value)
-      end
-    end
-
-    field :nullableNestedSum, LazySum, null: true do
-      argument :value, Integer, required: true
-    end
-    alias :nullable_nested_sum :nested_sum
-  end
-
-  using GraphQL::DeprecatedDSL
-  if RUBY_ENGINE == "jruby"
-    # JRuby doesn't support refinements, so the `using` above won't work
-    GraphQL::DeprecatedDSL.activate
-  end
-
-  class LazyQuery < GraphQL::Schema::Object
-    field :int, Integer, null: false do
-      argument :value, Integer, required: true
-      argument :plus, Integer, required: false, default_value: 0
-    end
-    def int(value:, plus:)
-      Wrapper.new(value + plus)
-    end
-
-    field :nested_sum, LazySum, null: false do
-      argument :value, Integer, required: true
-    end
-
-    def nested_sum(value:)
-      SumAll.new(value)
-    end
-
-    field :nullable_nested_sum, LazySum, null: true do
-      argument :value, Integer, required: true
-    end
-
-    def nullable_nested_sum(value:)
-      if value == MAGIC_NUMBER_THAT_RAISES_ERROR
-        Wrapper.new { raise GraphQL::ExecutionError.new("#{MAGIC_NUMBER_THAT_RAISES_ERROR} is unlucky") }
-      elsif value == MAGIC_NUMBER_THAT_RETURNS_NIL
-        nil
-      else
-        SumAll.new(value)
-      end
-    end
-
-    field :list_sum, [LazySum, null: true], null: true do
-      argument :values, [Integer], required: true, method_access: false
-    end
-    def list_sum(values:)
-      values.map { |v| v == MAGIC_NUMBER_THAT_RETURNS_NIL ? nil : v }
-    end
-  end
-
-  class SumAllInstrumentation
-    def initialize(counter:)
-      @counter = counter
-    end
-
-    def before_query(q)
-      add_check(q, "before #{q.selected_operation.name}")
-      # TODO not threadsafe
-      # This should use multiplex-level context
-      SumAll.all.clear
-    end
-
-    def after_query(q)
-      add_check(q, "after #{q.selected_operation.name}")
-    end
-
-    def before_multiplex(multiplex)
-      add_check(multiplex, "before multiplex #@counter")
-    end
-
-    def after_multiplex(multiplex)
-      add_check(multiplex, "after multiplex #@counter")
-    end
-
-    def add_check(obj, text)
-      checks = obj.context[:instrumentation_checks]
-      if checks
-        checks << text
-      end
-    end
-  end
-
-  class LazySchema < GraphQL::Schema
-    query(LazyQuery)
-    mutation(LazyQuery)
-    lazy_resolve(Wrapper, :item)
-    lazy_resolve(SumAll, :value)
-    instrument(:query, SumAllInstrumentation.new(counter: nil))
-    instrument(:multiplex, SumAllInstrumentation.new(counter: 1))
-    instrument(:multiplex, SumAllInstrumentation.new(counter: 2))
-
-    if TESTING_INTERPRETER
-      use GraphQL::Execution::Interpreter
-      use GraphQL::Analysis::AST
-    end
-
-    def self.sync_lazy(lazy)
-      if lazy.is_a?(SumAll) && lazy.own_value > 1000
-        lazy.value # clear the previous set
-        lazy.own_value - 900
-      else
-        super
-      end
-    end
-  end
-
-  def run_query(query_str, **rest)
-    LazySchema.execute(query_str, **rest)
-  end
-end

data/spec/support/magic_cards/schema.graphql

@@ -1,33 +0,0 @@
-type Card {
-  name: String!
-  printings: [Printing!]!
-  expansions: [Expansion!]!
-  colors: [Color!]!
-  convertedManaCost: Int!
-}
-
-type Expansion {
-  name: String!
-  symbol: String!
-  printings: [Printing!]!
-  cards: [Card!]!
-}
-
-type Printing {
-  card: Card!
-  expansion: Expansion!
-}
-
-enum Color {
-  RED
-  GREEN
-  BLACK
-  BLUE
-  WHITE
-  COLORLESS
-}
-
-type Query {
-  card(name: String!): Card
-  expansion(symbol: String!): Expansion
-}

data/spec/support/minimum_input_object.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-# This is the minimum required interface for an input object
-class MinimumInputObject
-  include Enumerable
-
-  def initialize(values)
-    @values = values
-  end
-
-  def each(&block)
-    @values.each(&block)
-  end
-
-  def [](key)
-    @values[key]
-  end
-
-  def key?(key)
-    @values.key?(key)
-  end
-end

data/spec/support/new_relic.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-# A stub for the NewRelic agent, so we can make assertions about how it is used
-if defined?(NewRelic)
-  raise "Expected NewRelic to be undefined, so that we could define a stub for it."
-end
-
-module NewRelic
-  TRANSACTION_NAMES = []
-  EXECUTION_SCOPES = []
-  # Reset state between tests
-  def self.clear_all
-    TRANSACTION_NAMES.clear
-    EXECUTION_SCOPES.clear
-  end
-  module Agent
-    def self.set_transaction_name(name)
-      TRANSACTION_NAMES << name
-    end
-
-    module MethodTracerHelpers
-      def self.trace_execution_scoped(trace_name)
-        EXECUTION_SCOPES << trace_name
-        yield
-      end
-    end
-  end
-end

data/spec/support/parser/filename_example.graphql

@@ -1,5 +0,0 @@
-{
-  node(id: 1) {
-    stuff
-  }
-}

data/spec/support/parser/filename_example_error_1.graphql

@@ -1,4 +0,0 @@
-{
-  node(id: 2) {
-    stuff
-}

data/spec/support/parser/filename_example_error_2.graphql

@@ -1,5 +0,0 @@
-{
-  node(id: 2) {
-    stuff "str"
-  }
-}

data/spec/support/parser/filename_example_invalid_utf8.graphql

@@ -1 +0,0 @@
-"�"

data/spec/support/skylight.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-# A stub for the Skylight agent, so we can make assertions about how it is used
-# Based on:
-#  - https://www.rubydoc.info/gems/skylight-core/2.0.2
-#  - https://www.rubydoc.info/gems/skylight/2.0.2
-if defined?(Skylight)
-  raise "Expected Skylight to be undefined, so that we could define a stub for it."
-end
-
-module Skylight
-  ENDPOINT_NAMES = []
-  TITLE_NAMES = []
-  # Reset state between tests
-  def self.clear_all
-    ENDPOINT_NAMES.clear
-    TITLE_NAMES.clear
-  end
-
-  def self.instrumenter
-    Instrumenter
-  end
-
-  def self.instrument(category:, title:)
-    TITLE_NAMES << title
-    yield
-  end
-
-  module Instrumenter
-    def self.current_trace
-      CurrentTrace
-    end
-  end
-
-  module CurrentTrace
-    def self.endpoint=(endpoint)
-      ENDPOINT_NAMES << endpoint
-    end
-  end
-end

data/spec/support/star_wars/schema.rb

@@ -1,464 +0,0 @@
-# frozen_string_literal: true
-module StarWars
-  # Adapted from graphql-relay-js
-  # https://github.com/graphql/graphql-relay-js/blob/master/src/__tests__/starWarsSchema.js
-
-  class Ship < GraphQL::Schema::Object
-    implements GraphQL::Relay::Node.interface
-    global_id_field :id
-    field :name, String, null: true
-    # Test cyclical connection types:
-    field :ships, Ship.connection_type, null: false
-  end
-
-  class BaseType < GraphQL::Schema::Object
-    graphql_name "Base"
-    implements GraphQL::Relay::Node.interface
-    global_id_field :id
-    field :name, String, null: false
-    def name
-      LazyWrapper.new {
-        if object.id.nil?
-          raise GraphQL::ExecutionError, "Boom!"
-        else
-          object.name
-        end
-      }
-    end
-    field :planet, String, null: true
-  end
-
-
-  class BaseEdge < GraphQL::Types::Relay::BaseEdge
-    node_type(BaseType)
-  end
-
-  class BaseConnection < GraphQL::Types::Relay::BaseConnection
-    edge_type(BaseEdge)
-  end
-
-  class BaseConnectionWithoutNodes < GraphQL::Types::Relay::BaseConnection
-    edge_type(BaseEdge, nodes_field: false)
-  end
-
-  class BasesConnectionWithTotalCountType < GraphQL::Types::Relay::BaseConnection
-    edge_type(BaseEdge, nodes_field: false)
-    nodes_field
-
-    field :total_count, Integer, null: true
-
-    def total_count
-      object.nodes.count
-    end
-  end
-
-  class CustomBaseEdge < GraphQL::Relay::Edge
-    def upcased_name
-      node.name.upcase
-    end
-
-    def upcased_parent_name
-      parent.name.upcase
-    end
-  end
-
-  class CustomBaseEdgeType < GraphQL::Types::Relay::BaseEdge
-    node_type(BaseType)
-    field :upcased_name, String, null: true
-    field :upcased_parent_name, String, null: true
-    field :edge_class_name, String, null: true
-
-    def edge_class_name
-      object.class.name
-    end
-  end
-
-  class CustomEdgeBaseConnectionType < GraphQL::Types::Relay::BaseConnection
-    edge_type(CustomBaseEdgeType, edge_class: CustomBaseEdge, nodes_field: true)
-    field :total_count_times_100, Integer, null: true
-    def total_count_times_100
-      object.nodes.count * 100
-    end
-
-    field :field_name, String, null: true
-    def field_name
-      object.field.name
-    end
-  end
-
-  class ShipsWithMaxPageSize < GraphQL::Schema::Resolver
-    argument :name_includes, String, required: false
-    type Ship.connection_type, null: true
-
-    def resolve(name_includes: nil)
-      all_ships = object.ships.map { |ship_id| StarWars::DATA["Ship"][ship_id] }
-      if name_includes
-        all_ships = all_ships.select { |ship| ship.name.include?(name_includes)}
-      end
-      all_ships
-    end
-  end
-
-  class ShipConnectionWithParentType < GraphQL::Types::Relay::BaseConnection
-    edge_type(Ship.edge_type)
-    field :parent_class_name, String, null: false
-
-    def parent_class_name
-      object.parent.class.name
-    end
-  end
-
-  class ShipsByResolver < GraphQL::Schema::Resolver
-    type ShipConnectionWithParentType, null: false
-
-    def resolve
-      object.ships.map { |ship_id| StarWars::DATA["Ship"][ship_id] }
-    end
-  end
-
-  class Faction < GraphQL::Schema::Object
-    implements GraphQL::Relay::Node.interface
-
-    field :id, ID, null: false
-    def id
-      GraphQL::Relay::GlobalIdResolve.new(type: Faction).call(object, {}, context)
-    end
-
-    field :name, String, null: true
-    field :ships, ShipConnectionWithParentType, connection: true, max_page_size: 1000, null: true do
-      argument :name_includes, String, required: false
-    end
-
-    field :shipsByResolver, resolver: ShipsByResolver, connection: true
-
-    def ships(name_includes: nil)
-      all_ships = object.ships.map {|ship_id| StarWars::DATA["Ship"][ship_id] }
-      if name_includes
-        case name_includes
-        when "error"
-          all_ships = GraphQL::ExecutionError.new("error from within connection")
-        when "raisedError"
-          raise GraphQL::ExecutionError.new("error raised from within connection")
-        when "lazyError"
-          all_ships = LazyWrapper.new { GraphQL::ExecutionError.new("lazy error from within connection") }
-        when "lazyRaisedError"
-          all_ships = LazyWrapper.new { raise GraphQL::ExecutionError.new("lazy raised error from within connection") }
-        when "null"
-          all_ships = nil
-        when "lazyObject"
-          prev_all_ships = all_ships
-          all_ships = LazyWrapper.new { prev_all_ships }
-        else
-          all_ships = all_ships.select { |ship| ship.name.include?(name_includes)}
-        end
-      end
-      all_ships
-    end
-
-    field :shipsWithMaxPageSize, "Ships with max page size", max_page_size: 2, resolver: ShipsWithMaxPageSize
-
-    field :bases, BasesConnectionWithTotalCountType, null: true, connection: true do
-      argument :nameIncludes, String, required: false
-      argument :complexOrder, Boolean, required: false
-    end
-
-    def bases(name_includes: nil, complex_order: nil)
-      all_bases = Base.where(id: object.bases)
-      if name_includes
-        all_bases = all_bases.where("name LIKE ?", "%#{name_includes}%")
-      end
-      if complex_order
-        all_bases = all_bases.order("bases.name DESC")
-      end
-      all_bases
-    end
-
-    field :basesClone, BaseConnection, null: true
-    field :basesByName, BaseConnection, null: true do
-      argument :order, String, default_value: "name", required: false
-    end
-    def bases_by_name(order: nil)
-      if order.present?
-        @object.bases.order(order)
-      else
-        @object.bases
-      end
-    end
-
-    def all_bases
-      Base.all
-    end
-
-    def all_bases_array
-      all_bases.to_a
-    end
-
-    field :basesWithMaxLimitRelation, BaseConnection, null: true, max_page_size: 2, resolver_method: :all_bases
-    field :basesWithMaxLimitArray, BaseConnection, null: true, max_page_size: 2, resolver_method: :all_bases_array
-    field :basesWithDefaultMaxLimitRelation, BaseConnection, null: true, resolver_method: :all_bases
-    field :basesWithDefaultMaxLimitArray, BaseConnection, null: true, resolver_method: :all_bases_array
-    field :basesWithLargeMaxLimitRelation, BaseConnection, null: true, max_page_size: 1000, resolver_method: :all_bases
-    field :basesWithoutNodes, BaseConnectionWithoutNodes, null: true, resolver_method: :all_bases_array
-
-    field :basesAsSequelDataset, BasesConnectionWithTotalCountType, null: true, connection: true, max_page_size: 1000 do
-      argument :nameIncludes, String, required: false
-    end
-
-    def bases_as_sequel_dataset(name_includes: nil)
-      all_bases = SequelBase.where(faction_id: @object.id)
-      if name_includes
-        all_bases = all_bases.where(Sequel.like(:name, "%#{name_includes}%"))
-      end
-      all_bases
-    end
-
-    field :basesWithCustomEdge, CustomEdgeBaseConnectionType, null: true, connection: true, resolver_method: :lazy_bases
-
-    def lazy_bases
-      LazyNodesWrapper.new(object.bases)
-    end
-  end
-
-  class IntroduceShipMutation < GraphQL::Schema::RelayClassicMutation
-    description "Add a ship to this faction"
-
-    # Nested under `input` in the query:
-    argument :ship_name, String, required: false
-    argument :faction_id, ID, required: true
-
-    # Result may have access to these fields:
-    field :ship_edge, Ship.edge_type, null: true
-    field :faction, Faction, null: true
-    field :aliased_faction, Faction, hash_key: :aliased_faction, null: true
-
-    def resolve(ship_name: nil, faction_id:)
-      if ship_name == 'Millennium Falcon'
-        GraphQL::ExecutionError.new("Sorry, Millennium Falcon ship is reserved")
-      elsif ship_name == 'Leviathan'
-        raise GraphQL::ExecutionError.new("🔥")
-      elsif ship_name == "Ebon Hawk"
-        LazyWrapper.new { raise GraphQL::ExecutionError.new("💥")}
-      else
-        ship = DATA.create_ship(ship_name, faction_id)
-        faction = DATA["Faction"][faction_id]
-        connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(faction.ships)
-        ships_connection = connection_class.new(faction.ships, {ship_name: ship_name, faction: faction})
-        ship_edge = GraphQL::Relay::Edge.new(ship, ships_connection)
-        result = {
-          ship_edge: ship_edge, # support new-style, too
-          faction: faction,
-          aliased_faction: faction,
-        }
-        if ship_name == "Slave II"
-          LazyWrapper.new(result)
-        else
-          result
-        end
-      end
-    end
-  end
-
-  # GraphQL-Batch knockoff
-  class LazyLoader
-    def self.defer(ctx, model, id)
-      ids = ctx.namespace(:loading)[model] ||= []
-      ids << id
-      self.new(model: model, id: id, context: ctx)
-    end
-
-    def initialize(model:, id:, context:)
-      @model = model
-      @id = id
-      @context = context
-    end
-
-    def value
-      loaded = @context.namespace(:loaded)[@model] ||= {}
-      if loaded.empty?
-        ids = @context.namespace(:loading)[@model]
-        # Example custom tracing
-        @context.trace("lazy_loader", { ids: ids, model: @model}) do
-          records = @model.where(id: ids)
-          records.each do |record|
-            loaded[record.id.to_s] = record
-          end
-        end
-      end
-
-      loaded[@id]
-    end
-  end
-
-  class LazyWrapper
-    def initialize(value = nil, &block)
-      if block_given?
-        @lazy_value = block
-      else
-        @value = value
-      end
-    end
-
-    def value
-      @resolved_value = @value || @lazy_value.call
-    end
-  end
-
-  LazyNodesWrapper = Struct.new(:relation)
-  class LazyNodesRelationConnection < GraphQL::Relay::RelationConnection
-    def initialize(wrapper, *args)
-      super(wrapper.relation, *args)
-    end
-
-    def edge_nodes
-      LazyWrapper.new { super }
-    end
-  end
-
-  GraphQL::Relay::BaseConnection.register_connection_implementation(LazyNodesWrapper, LazyNodesRelationConnection)
-
-  class QueryType < GraphQL::Schema::Object
-    graphql_name "Query"
-
-    field :rebels, Faction, null: true
-    def rebels
-      StarWars::DATA["Faction"]["1"]
-    end
-
-    field :empire, Faction, null: true
-    def empire
-      StarWars::DATA["Faction"]["2"]
-    end
-
-    field :largestBase, BaseType, null: true
-
-    def largest_base
-      Base.find(3)
-    end
-
-    field :newestBasesGroupedByFaction, BaseConnection, null: true
-
-    def newest_bases_grouped_by_faction
-      Base
-        .having('id in (select max(id) from bases group by faction_id)')
-        .group(:id)
-        .order('faction_id desc')
-    end
-
-    field :basesWithNullName, BaseConnection, null: false
-
-    def bases_with_null_name
-      [OpenStruct.new(id: nil)]
-    end
-
-    if TESTING_INTERPRETER
-      add_field(GraphQL::Types::Relay::NodeField)
-    else
-      field :node, field: GraphQL::Relay::Node.field
-    end
-
-    if TESTING_INTERPRETER
-      field :node_with_custom_resolver, GraphQL::Types::Relay::Node, null: true do
-        argument :id, ID, required: true
-      end
-      def node_with_custom_resolver(id:)
-        StarWars::DATA["Faction"]["1"]
-      end
-    else
-      custom_node_field = GraphQL::Relay::Node.field do
-        resolve ->(_, _, _) { StarWars::DATA["Faction"]["1"] }
-      end
-      field :nodeWithCustomResolver, field: custom_node_field
-    end
-
-    if TESTING_INTERPRETER
-      add_field(GraphQL::Types::Relay::NodesField)
-    else
-      field :nodes, field: GraphQL::Relay::Node.plural_field
-    end
-
-    if TESTING_INTERPRETER
-      field :nodes_with_custom_resolver, [GraphQL::Types::Relay::Node, null: true], null: true do
-        argument :ids, [ID], required: true
-      end
-      def nodes_with_custom_resolver(ids:)
-        [StarWars::DATA["Faction"]["1"], StarWars::DATA["Faction"]["2"]]
-      end
-    else
-      field :nodesWithCustomResolver, field: GraphQL::Relay::Node.plural_field(
-        resolve: ->(_, _, _) { [StarWars::DATA["Faction"]["1"], StarWars::DATA["Faction"]["2"]] }
-      )
-    end
-
-    field :batchedBase, BaseType, null: true do
-      argument :id, ID, required: true
-    end
-
-    def batched_base(id:)
-      LazyLoader.defer(@context, Base, id)
-    end
-  end
-
-  class MutationType < GraphQL::Schema::Object
-    graphql_name "Mutation"
-    field :introduceShip, mutation: IntroduceShipMutation
-  end
-
-  class ClassNameRecorder
-    def initialize(context_key)
-      @context_key = context_key
-    end
-
-    def instrument(type, field)
-      inner_resolve = field.resolve_proc
-      key = @context_key
-      field.redefine {
-        resolve ->(o, a, c) {
-          res = inner_resolve.call(o, a, c)
-          if c[key]
-            c[key] << res.class.name
-          end
-          res
-        }
-      }
-    end
-  end
-
-  class Schema < GraphQL::Schema
-    query(QueryType)
-    mutation(MutationType)
-    default_max_page_size 3
-
-    if TESTING_INTERPRETER
-      use GraphQL::Execution::Interpreter
-    end
-
-    def self.resolve_type(type, object, ctx)
-      if object == :test_error
-        :not_a_type
-      elsif object.is_a?(Base)
-        BaseType
-      elsif DATA["Faction"].values.include?(object)
-        Faction
-      elsif DATA["Ship"].values.include?(object)
-        Ship
-      else
-        nil
-      end
-    end
-
-    def self.object_from_id(node_id, ctx)
-      type_name, id = GraphQL::Schema::UniqueWithinType.decode(node_id)
-      StarWars::DATA[type_name][id]
-    end
-
-    def self.id_from_object(object, type, ctx)
-      GraphQL::Schema::UniqueWithinType.encode(type.graphql_name, object.id)
-    end
-
-    lazy_resolve(LazyWrapper, :value)
-    lazy_resolve(LazyLoader, :value)
-
-    instrument(:field, ClassNameRecorder.new(:before_built_ins))
-    instrument(:field, ClassNameRecorder.new(:after_built_ins), after_built_ins: true)
-  end
-end