graphql 1.7.14 → 1.8.0.pre1

data/lib/graphql/language/printer.rb

@@ -1,351 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module Language
-    class Printer
-      # Turn an arbitrary AST node back into a string.
-      #
-      # @example Turning a document into a query string
-      #    document = GraphQL.parse(query_string)
-      #    GraphQL::Language::Printer.new.print(document)
-      #    # => "{ ... }"
-      #
-      #
-      # @example Building a custom printer
-      #
-      #  class MyPrinter < GraphQL::Language::Printer
-      #    def print_argument(arg)
-      #      "#{arg.name}: <HIDDEN>"
-      #    end
-      #  end
-      #
-      #  MyPrinter.new.print(document)
-      #  # => "mutation { pay(creditCard: <HIDDEN>) { success } }"
-      #
-      #
-      # @param indent [String] Whitespace to add to the printed node
-      # @return [String] Valid GraphQL for `node`
-      def print(node, indent: "")
-        print_node(node, indent: indent)
-      end
-
-      protected
-
-      def print_document(document)
-        document.definitions.map { |d| print_node(d) }.join("\n\n")
-      end
-
-      def print_argument(argument)
-        "#{argument.name}: #{print_node(argument.value)}".dup
-      end
-
-      def print_directive(directive)
-        out = "@#{directive.name}".dup
-
-        if directive.arguments.any?
-          out << "(#{directive.arguments.map { |a| print_argument(a) }.join(", ")})"
-        end
-
-        out
-      end
-
-      def print_enum(enum)
-        "#{enum.name}".dup
-      end
-
-      def print_null_value
-        "null".dup
-      end
-
-      def print_field(field, indent: "")
-        out = "#{indent}".dup
-        out << "#{field.alias}: " if field.alias
-        out << "#{field.name}"
-        out << "(#{field.arguments.map { |a| print_argument(a) }.join(", ")})" if field.arguments.any?
-        out << print_directives(field.directives)
-        out << print_selections(field.selections, indent: indent)
-        out
-      end
-
-      def print_fragment_definition(fragment_def, indent: "")
-        out = "#{indent}fragment #{fragment_def.name}".dup
-        if fragment_def.type
-          out << " on #{print_node(fragment_def.type)}"
-        end
-        out << print_directives(fragment_def.directives)
-        out << print_selections(fragment_def.selections, indent: indent)
-        out
-      end
-
-      def print_fragment_spread(fragment_spread, indent: "")
-        out = "#{indent}...#{fragment_spread.name}".dup
-        out << print_directives(fragment_spread.directives)
-        out
-      end
-
-      def print_inline_fragment(inline_fragment, indent: "")
-        out = "#{indent}...".dup
-        if inline_fragment.type
-          out << " on #{print_node(inline_fragment.type)}"
-        end
-        out << print_directives(inline_fragment.directives)
-        out << print_selections(inline_fragment.selections, indent: indent)
-        out
-      end
-
-      def print_input_object(input_object)
-        "{#{input_object.arguments.map { |a| "#{a.name}: #{print(a.value)}" }.join(", ")}}"
-      end
-
-      def print_list_type(list_type)
-        "[#{print_node(list_type.of_type)}]".dup
-      end
-
-      def print_non_null_type(non_null_type)
-        "#{print_node(non_null_type.of_type)}!".dup
-      end
-
-      def print_operation_definition(operation_definition, indent: "")
-        out = "#{indent}#{operation_definition.operation_type}".dup
-        out << " #{operation_definition.name}" if operation_definition.name
-
-        if operation_definition.variables.any?
-          out << "(#{operation_definition.variables.map { |v| print_variable_definition(v) }.join(", ")})"
-        end
-
-        out << print_directives(operation_definition.directives)
-        out << print_selections(operation_definition.selections, indent: indent)
-        out
-      end
-
-      def print_type_name(type_name)
-        "#{type_name.name}".dup
-      end
-
-      def print_variable_definition(variable_definition)
-        out = "$#{variable_definition.name}: #{print_node(variable_definition.type)}".dup
-        out << " = #{print_node(variable_definition.default_value)}" unless variable_definition.default_value.nil?
-        out
-      end
-
-      def print_variable_identifier(variable_identifier)
-        "$#{variable_identifier.name}".dup
-      end
-
-      def print_schema_definition(schema)
-        if (schema.query.nil? || schema.query == 'Query') &&
-           (schema.mutation.nil? || schema.mutation == 'Mutation') &&
-           (schema.subscription.nil? || schema.subscription == 'Subscription')
-          return
-        end
-
-        out = "schema {\n".dup
-        out << "  query: #{schema.query}\n" if schema.query
-        out << "  mutation: #{schema.mutation}\n" if schema.mutation
-        out << "  subscription: #{schema.subscription}\n" if schema.subscription
-        out << "}"
-      end
-
-      def print_scalar_type_definition(scalar_type)
-        out = print_description(scalar_type)
-        out << "scalar #{scalar_type.name}"
-        out << print_directives(scalar_type.directives)
-      end
-
-      def print_object_type_definition(object_type)
-        out = print_description(object_type)
-        out << "type #{object_type.name}"
-        out << " implements " << object_type.interfaces.map(&:name).join(" & ") unless object_type.interfaces.empty?
-        out << print_directives(object_type.directives)
-        out << print_field_definitions(object_type.fields)
-      end
-
-      def print_input_value_definition(input_value)
-        out = "#{input_value.name}: #{print_node(input_value.type)}".dup
-        out << " = #{print_node(input_value.default_value)}" unless input_value.default_value.nil?
-        out << print_directives(input_value.directives)
-      end
-
-      def print_arguments(arguments, indent: "")
-        if arguments.all?{ |arg| !arg.description }
-          return "(#{arguments.map{ |arg| print_input_value_definition(arg) }.join(", ")})"
-        end
-
-        out = "(\n".dup
-        out << arguments.map.with_index{ |arg, i|
-          "#{print_description(arg, indent: "  " + indent, first_in_block: i == 0)}  #{indent}"\
-          "#{print_input_value_definition(arg)}"
-        }.join("\n")
-        out << "\n#{indent})"
-      end
-
-      def print_field_definition(field)
-        out = field.name.dup
-        unless field.arguments.empty?
-          out << print_arguments(field.arguments, indent: "  ")
-        end
-        out << ": #{print_node(field.type)}"
-        out << print_directives(field.directives)
-      end
-
-      def print_interface_type_definition(interface_type)
-        out = print_description(interface_type)
-        out << "interface #{interface_type.name}"
-        out << print_directives(interface_type.directives)
-        out << print_field_definitions(interface_type.fields)
-      end
-
-      def print_union_type_definition(union_type)
-        out = print_description(union_type)
-        out << "union #{union_type.name}"
-        out << print_directives(union_type.directives)
-        out << " = " + union_type.types.map(&:name).join(" | ")
-      end
-
-      def print_enum_type_definition(enum_type)
-        out = print_description(enum_type)
-        out << "enum #{enum_type.name}#{print_directives(enum_type.directives)} {\n"
-        enum_type.values.each.with_index do |value, i|
-          out << print_description(value, indent: '  ', first_in_block: i == 0)
-          out << print_enum_value_definition(value)
-        end
-        out << "}"
-      end
-
-      def print_enum_value_definition(enum_value)
-        out = "  #{enum_value.name}".dup
-        out << print_directives(enum_value.directives)
-        out << "\n"
-      end
-
-      def print_input_object_type_definition(input_object_type)
-        out = print_description(input_object_type)
-        out << "input #{input_object_type.name}"
-        out << print_directives(input_object_type.directives)
-        out << " {\n"
-        input_object_type.fields.each.with_index do |field, i|
-          out << print_description(field, indent: '  ', first_in_block: i == 0)
-          out << "  #{print_input_value_definition(field)}\n"
-        end
-        out << "}"
-      end
-
-      def print_directive_definition(directive)
-        out = print_description(directive)
-        out << "directive @#{directive.name}"
-
-        if directive.arguments.any?
-          out << print_arguments(directive.arguments)
-        end
-
-        out << " on #{directive.locations.join(' | ')}"
-      end
-
-      def print_description(node, indent: "", first_in_block: true)
-        return ''.dup unless node.description
-
-        description = indent != '' && !first_in_block ? "\n".dup : "".dup
-        description << GraphQL::Language::Comments.commentize(node.description, indent: indent)
-      end
-
-      def print_field_definitions(fields)
-        out = " {\n".dup
-        fields.each.with_index do |field, i|
-          out << print_description(field, indent: '  ', first_in_block: i == 0)
-          out << "  #{print_field_definition(field)}\n"
-        end
-        out << "}"
-      end
-
-      def print_directives(directives)
-        if directives.any?
-          directives.map { |d| " #{print_directive(d)}" }.join
-        else
-          ""
-        end
-      end
-
-      def print_selections(selections, indent: "")
-        if selections.any?
-          out = " {\n".dup
-          selections.each do |selection|
-            out << print_node(selection, indent: indent + "  ") << "\n"
-          end
-          out << "#{indent}}"
-        else
-          ""
-        end
-      end
-
-      def print_node(node, indent: "")
-        case node
-        when Nodes::Document
-          print_document(node)
-        when Nodes::Argument
-          print_argument(node)
-        when Nodes::Directive
-          print_directive(node)
-        when Nodes::Enum
-          print_enum(node)
-        when Nodes::NullValue
-          print_null_value
-        when Nodes::Field
-          print_field(node, indent: indent)
-        when Nodes::FragmentDefinition
-          print_fragment_definition(node, indent: indent)
-        when Nodes::FragmentSpread
-          print_fragment_spread(node, indent: indent)
-        when Nodes::InlineFragment
-          print_inline_fragment(node, indent: indent)
-        when Nodes::InputObject
-          print_input_object(node)
-        when Nodes::ListType
-          print_list_type(node)
-        when Nodes::NonNullType
-          print_non_null_type(node)
-        when Nodes::OperationDefinition
-          print_operation_definition(node, indent: indent)
-        when Nodes::TypeName
-          print_type_name(node)
-        when Nodes::VariableDefinition
-          print_variable_definition(node)
-        when Nodes::VariableIdentifier
-          print_variable_identifier(node)
-        when Nodes::SchemaDefinition
-          print_schema_definition(node)
-        when Nodes::ScalarTypeDefinition
-          print_scalar_type_definition(node)
-        when Nodes::ObjectTypeDefinition
-          print_object_type_definition(node)
-        when Nodes::InputValueDefinition
-          print_input_value_definition(node)
-        when Nodes::FieldDefinition
-          print_field_definition(node)
-        when Nodes::InterfaceTypeDefinition
-          print_interface_type_definition(node)
-        when Nodes::UnionTypeDefinition
-          print_union_type_definition(node)
-        when Nodes::EnumTypeDefinition
-          print_enum_type_definition(node)
-        when Nodes::EnumValueDefinition
-          print_enum_value_definition(node)
-        when Nodes::InputObjectTypeDefinition
-          print_input_object_type_definition(node)
-        when Nodes::DirectiveDefinition
-          print_directive_definition(node)
-        when FalseClass, Float, Integer, NilClass, String, TrueClass, Symbol
-          GraphQL::Language.serialize(node)
-        when Array
-          "[#{node.map { |v| print_node(v) }.join(", ")}]".dup
-        when Hash
-          "{#{node.map { |k, v| "#{k}: #{print_node(v)}" }.join(", ")}}".dup
-        else
-          GraphQL::Language.serialize(node.to_s)
-        end
-      end
-
-      private
-
-      attr_reader :node
-    end
-  end
-end

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Tracing
-    class DataDogTracing < PlatformTracing
-      self.platform_keys = {
-        'lex' => 'lex.graphql',
-        'parse' => 'parse.graphql',
-        'validate' => 'validate.graphql',
-        'analyze_query' => 'analyze.graphql',
-        'analyze_multiplex' => 'analyze.graphql',
-        'execute_multiplex' => 'execute.graphql',
-        'execute_query' => 'execute.graphql',
-        'execute_query_lazy' => 'execute.graphql',
-      }
-
-      def platform_trace(platform_key, key, data)
-        tracer.trace(platform_key, service: service_name) do |span|
-          span.span_type = 'custom'
-
-          if key == 'execute_multiplex'
-            operations = data[:multiplex].queries.map(&:selected_operation_name).join(', ')
-            span.resource = operations unless operations.empty?
-          end
-
-          if key == 'execute_query'
-            span.set_tag(:selected_operation_name, data[:query].selected_operation_name)
-            span.set_tag(:selected_operation_type, data[:query].selected_operation.operation_type)
-            span.set_tag(:query_string, data[:query].query_string)
-          end
-
-          yield
-        end
-      end
-
-      def service_name
-        options.fetch(:service, 'ruby-graphql')
-      end
-
-      def tracer
-        options.fetch(:tracer, Datadog.tracer)
-      end
-
-      def platform_field_key(type, field)
-        "#{type.name}.#{field.name}"
-      end
-    end
-  end
-end

data/spec/graphql/execution/instrumentation_spec.rb

@@ -1,165 +0,0 @@
-# frozen_string_literal: true
-require "spec_helper"
-
-describe GraphQL::Schema do
-  describe "instrumentation teardown bug" do
-    # This instrumenter records that it ran,
-    # or raises an error if instructed to do so
-    class InstrumenterError < StandardError
-      attr_reader :key
-      def initialize(key)
-        @key = key
-        super()
-      end
-    end
-
-    class LogInstrumenter
-      def before_query(unit_of_work)
-        run_hook(unit_of_work, "begin")
-      end
-
-      def after_query(unit_of_work)
-        run_hook(unit_of_work, "end")
-      end
-
-      alias :before_multiplex :before_query
-      alias :after_multiplex :after_query
-
-      private
-
-      def run_hook(unit_of_work, event_name)
-        unit_of_work.context[log_key(event_name)] = true
-        if unit_of_work.context[raise_key(event_name)]
-          raise InstrumenterError.new(log_key(event_name))
-        end
-      end
-
-      def log_key(event_name)
-        context_key("did_#{event_name}")
-      end
-
-      def raise_key(event_name)
-        context_key("should_raise_#{event_name}")
-      end
-
-      def context_key(suffix)
-        prefix = self.class.name.sub("Instrumenter", "").downcase
-        :"#{prefix}_instrumenter_#{suffix}"
-      end
-    end
-
-    class FirstInstrumenter < LogInstrumenter; end
-    class SecondInstrumenter < LogInstrumenter; end
-
-    let(:query_type) {
-      GraphQL::ObjectType.define do
-        name "Query"
-        field :int, types.Int do
-          argument :value, types.Int
-          resolve ->(obj, args, ctx) { args.value }
-        end
-      end
-    }
-
-    let(:schema) {
-      spec = self
-      GraphQL::Schema.define do
-        query(spec.query_type)
-        instrument(:query, FirstInstrumenter.new)
-        instrument(:query, SecondInstrumenter.new)
-      end
-    }
-
-    describe "query instrumenters" do
-      it "before_query of the 2nd instrumenter does not run but after_query does" do
-        context = {second_instrumenter_should_raise_begin: true}
-        assert_raises InstrumenterError do
-          schema.execute(" { int(value: 2) } ", context: context)
-        end
-        assert context[:first_instrumenter_did_begin]
-        assert context[:first_instrumenter_did_end]
-        assert context[:second_instrumenter_did_begin]
-        refute context[:second_instrumenter_did_end]
-      end
-
-      it "runs after_query even if a previous after_query raised an error" do
-        context = {second_instrumenter_should_raise_end: true}
-        err = assert_raises InstrumenterError do
-          schema.execute(" { int(value: 2) } ", context: context)
-        end
-        # The error came from the second instrumenter:
-        assert_equal :second_instrumenter_did_end, err.key
-        # But the first instrumenter still got a chance to teardown
-        assert context[:first_instrumenter_did_begin]
-        assert context[:first_instrumenter_did_end]
-        assert context[:second_instrumenter_did_begin]
-        assert context[:second_instrumenter_did_end]
-      end
-    end
-
-    describe "within a multiplex" do
-      let(:multiplex_schema) {
-        schema.redefine {
-          instrument(:multiplex, FirstInstrumenter.new)
-          instrument(:multiplex, SecondInstrumenter.new)
-        }
-      }
-
-      it "only runs after_multiplex if before_multiplex finished" do
-        multiplex_ctx = {second_instrumenter_should_raise_begin: true}
-        query_1_ctx = {}
-        query_2_ctx = {}
-        assert_raises InstrumenterError do
-          multiplex_schema.multiplex(
-            [
-              {query: "{int(value: 1)}", context: query_1_ctx},
-              {query: "{int(value: 2)}", context: query_2_ctx},
-            ],
-            context: multiplex_ctx
-          )
-        end
-
-        assert multiplex_ctx[:first_instrumenter_did_begin]
-        assert multiplex_ctx[:first_instrumenter_did_end]
-        assert multiplex_ctx[:second_instrumenter_did_begin]
-        refute multiplex_ctx[:second_instrumenter_did_end]
-        # No query instrumentation was run at all
-        assert_equal 0, query_1_ctx.size
-        assert_equal 0, query_2_ctx.size
-      end
-
-      it "does full and partial query runs" do
-        multiplex_ctx = {}
-        query_1_ctx = {}
-        query_2_ctx = {second_instrumenter_should_raise_begin: true}
-        assert_raises InstrumenterError do
-          multiplex_schema.multiplex(
-            [
-              { query: " { int(value: 2) } ", context: query_1_ctx },
-              { query: " { int(value: 2) } ", context: query_2_ctx },
-            ],
-            context: multiplex_ctx
-          )
-        end
-
-        # multiplex got a full run
-        assert multiplex_ctx[:first_instrumenter_did_begin]
-        assert multiplex_ctx[:first_instrumenter_did_end]
-        assert multiplex_ctx[:second_instrumenter_did_begin]
-        assert multiplex_ctx[:second_instrumenter_did_end]
-
-        # query 1 got a full run
-        assert query_1_ctx[:first_instrumenter_did_begin]
-        assert query_1_ctx[:first_instrumenter_did_end]
-        assert query_1_ctx[:second_instrumenter_did_begin]
-        assert query_1_ctx[:second_instrumenter_did_end]
-
-        # query 2 got a partial run
-        assert query_2_ctx[:first_instrumenter_did_begin]
-        assert query_2_ctx[:first_instrumenter_did_end]
-        assert query_2_ctx[:second_instrumenter_did_begin]
-        refute query_2_ctx[:second_instrumenter_did_end]
-      end
-    end
-  end
-end