graphql 1.8.0.pre1 → 1.8.0.pre2

data/lib/graphql/language/lexer.rb

@@ -387,7 +387,7 @@ def self.run_lexer(query_string)
 									begin
 										te = p+1;
 										begin
-											emit_string(ts + 1, te - 1, meta) 
+											emit_string(ts + 1, te, meta) 
 										end
 										
 									end
@@ -791,7 +791,7 @@ def self.run_lexer(query_string)
 										begin
 											p = ((te))-1;
 											begin
-												emit_string(ts + 1, te - 1, meta) 
+												emit_string(ts + 1, te, meta) 
 											end
 											
 										end
@@ -1304,7 +1304,7 @@ PACK_DIRECTIVE = "c*"
 UTF_8_ENCODING = "UTF-8"
 
 def self.emit_string(ts, te, meta)
-value = meta[:data][ts...te].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING)
+value = meta[:data][ts...te - 1].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING)
 if value !~ VALID_STRING
 meta[:tokens] << token = GraphQL::Language::Token.new(
 name: :BAD_UNICODE_ESCAPE,

data/lib/graphql/language/lexer.rl

@@ -75,7 +75,7 @@
     RBRACKET      => { emit(:RBRACKET, ts, te, meta) };
     LBRACKET      => { emit(:LBRACKET, ts, te, meta) };
     COLON         => { emit(:COLON, ts, te, meta) };
-    QUOTED_STRING => { emit_string(ts + 1, te - 1, meta) };
+    QUOTED_STRING => { emit_string(ts + 1, te, meta) };
     VAR_SIGN      => { emit(:VAR_SIGN, ts, te, meta) };
     DIR_SIGN      => { emit(:DIR_SIGN, ts, te, meta) };
     ELLIPSIS      => { emit(:ELLIPSIS, ts, te, meta) };
@@ -189,7 +189,7 @@ module GraphQL
       UTF_8_ENCODING = "UTF-8"
 
       def self.emit_string(ts, te, meta)
-        value = meta[:data][ts...te].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING)
+        value = meta[:data][ts...te - 1].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING)
         if value !~ VALID_STRING
           meta[:tokens] << token = GraphQL::Language::Token.new(
             name: :BAD_UNICODE_ESCAPE,

data/lib/graphql/language/token.rb

@@ -5,7 +5,10 @@ module GraphQL
     # Contains type, value and position data.
     class Token
       # @return [Symbol] The kind of token this is
-      attr_reader :name, :prev_token, :line
+      attr_reader :name
+      # @return [String] The text of this token
+      attr_reader :value
+      attr_reader :prev_token, :line, :col
 
       def initialize(value:, name:, line:, col:, prev_token:)
         @name = name
@@ -15,13 +18,17 @@ module GraphQL
         @prev_token = prev_token
       end
 
-      def to_s; @value; end
+      alias to_s value
       def to_i; @value.to_i; end
       def to_f; @value.to_f; end
 
       def line_and_column
         [@line, @col]
       end
+
+      def inspect
+        "(#{@name} #{@value.inspect} [#{@line}:#{@col}])"
+      end
     end
   end
 end

data/lib/graphql/query.rb

@@ -47,6 +47,10 @@ module GraphQL
       with_prepared_ast { @document }
     end
 
+    def inspect
+      "query ..."
+    end
+
     # @return [String, nil] The name of the operation to run (may be inferred)
     def selected_operation_name
       return nil unless selected_operation

data/lib/graphql/railtie.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative './upgrader/member'
+require_relative './upgrader/schema'
+
+module GraphQL
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      namespace :graphql do
+        task :upgrade, [:dir] do |t, args|
+          unless (dir = args[:dir])
+            fail 'You have to give me a directory where your GraphQL schema and types live. ' \
+             'For example: `bin/rake graphql:upgrade[app/graphql/**/*]`'
+          end
+
+          Dir[dir].each do |file|
+            # Members (types, interfaces, etc.)
+            if file =~ /.*_(type|interface|enum|union|)\.rb$/
+              Rake::Task["graphql:upgrade:member"].execute(Struct.new(:member_file).new(file))
+            end
+          end
+        end
+
+        namespace :upgrade do
+          task :create_base_objects, [:base_dir] do |t, args|
+            base_dir = args.base_dir
+
+            destination_file = File.join(base_dir, "types", "base_enum.rb")
+            unless File.exists?(destination_file)
+              FileUtils.mkdir_p(File.dirname(destination_file))
+              File.open(destination_file, 'w') do |f|
+                f.write "class Types::BaseEnum < GraphQL::Schema::Enum; end"
+              end
+            end
+
+            destination_file = File.join(base_dir, "types", "base_union.rb")
+            unless File.exists?(destination_file)
+              FileUtils.mkdir_p(File.dirname(destination_file))
+              File.open(destination_file, 'w') do |f|
+                f.write "class Types::BaseUnion < GraphQL::Schema::Union; end"
+              end
+            end
+
+            destination_file = File.join(base_dir, "types", "base_interface.rb")
+            unless File.exists?(destination_file)
+              FileUtils.mkdir_p(File.dirname(destination_file))
+              File.open(destination_file, 'w') do |f|
+                f.write "class Types::BaseInterface < GraphQL::Schema::Interface; end"
+              end
+            end
+
+            destination_file = File.join(base_dir, "types", "base_object.rb")
+            unless File.exists?(destination_file)
+              File.open(destination_file, 'w') do |f|
+                f.write "class Types::BaseObject < GraphQL::Schema::Object; end"
+              end
+            end
+          end
+
+          task :schema, [:schema_file] do |t, args|
+            schema_file = args.schema_file
+
+            upgrader = GraphQL::Upgrader::Schema.new File.read(schema_file)
+
+            puts "- Transforming schema #{schema_file}"
+            File.open(schema_file, 'w') { |f| f.write upgrader.upgrade }
+          end
+
+          task :member, [:member_file] do |t, args|
+            member_file = args.member_file
+
+            upgrader = GraphQL::Upgrader::Member.new File.read(member_file)
+            next unless upgrader.upgradeable?
+
+            puts "- Transforming member #{member_file}"
+            File.open(member_file, 'w') { |f| f.write upgrader.upgrade }
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/graphql/relay/relation_connection.rb

@@ -7,11 +7,11 @@ module GraphQL
     # - `Sequel::Dataset`
     class RelationConnection < BaseConnection
       def cursor_from_node(item)
-        item_index = paged_nodes_array.index(item)
+        item_index = paged_nodes.index(item)
         if item_index.nil?
           raise("Can't generate cursor, item not found in connection: #{item}")
         else
-          offset = item_index + 1 + ((relation_offset(paged_nodes) || 0) - (relation_offset(sliced_nodes) || 0))
+          offset = item_index + 1 + ((paged_nodes_offset || 0) - (relation_offset(sliced_nodes) || 0))
 
           if after
             offset += offset_from_cursor(after)
@@ -25,7 +25,7 @@ module GraphQL
 
       def has_next_page
         if first
-          paged_nodes_length >= first && sliced_nodes_count > first
+          paged_nodes.length >= first && sliced_nodes_count > first
         elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && last
           sliced_nodes_count > last
         else
@@ -35,7 +35,7 @@ module GraphQL
 
       def has_previous_page
         if last
-          paged_nodes_length >= last && sliced_nodes_count > last
+          paged_nodes.length >= last && sliced_nodes_count > last
         elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && after
           # We've already paginated through the collection a bit,
           # there are nodes behind us
@@ -64,6 +64,7 @@ module GraphQL
       private
 
       # apply first / last limit results
+      # @return [Array]
       def paged_nodes
         return @paged_nodes if defined? @paged_nodes
 
@@ -94,7 +95,14 @@ module GraphQL
           end
         end
 
-        @paged_nodes = items
+        # Store this here so we can convert the relation to an Array
+        # (this avoids an extra DB call on Sequel)
+        @paged_nodes_offset = relation_offset(items)
+        @paged_nodes = items.to_a
+      end
+
+      def paged_nodes_offset
+        paged_nodes && @paged_nodes_offset
       end
 
       def relation_offset(relation)
@@ -166,19 +174,6 @@ module GraphQL
       def offset_from_cursor(cursor)
         decode(cursor).to_i
       end
-
-      def paged_nodes_array
-        return @paged_nodes_array if defined?(@paged_nodes_array)
-        @paged_nodes_array = paged_nodes.to_a
-      end
-
-      def paged_nodes_length
-        if paged_nodes.respond_to?(:length)
-          paged_nodes.length
-        else
-          paged_nodes_array.length
-        end
-      end
     end
 
     if defined?(ActiveRecord::Relation)

data/lib/graphql/schema.rb

@@ -570,6 +570,12 @@ module GraphQL
       GraphQL::Schema::Printer.print_schema(self, only: only, except: except, context: context)
     end
 
+    # Return the GraphQL::Language::Document IDL AST for the schema
+    # @return [GraphQL::Language::Document]
+    def to_document
+      GraphQL::Language::DocumentFromSchemaDefinition.new(self).document
+    end
+
     # Return the Hash response of {Introspection::INTROSPECTION_QUERY}.
     # @param context [Hash]
     # @param only [<#call(member, ctx)>]

data/lib/graphql/schema/argument.rb

@@ -18,7 +18,7 @@ module GraphQL
 
       def to_graphql
         argument = GraphQL::Argument.new
-        argument.name = @name
+        argument.name = Member::BuildType.camelize(@name)
         argument.type = -> {
           Member::BuildType.parse_type(@type_expr, null: @null)
         }

data/lib/graphql/schema/build_from_definition.rb

@@ -191,6 +191,8 @@ module GraphQL
             default_value.name
           when GraphQL::Language::Nodes::NullValue
             nil
+          when GraphQL::Language::Nodes::InputObject
+            default_value.to_h
           else
             default_value
           end

data/lib/graphql/schema/field.rb

@@ -16,7 +16,7 @@ module GraphQL
       def initialize(name, return_type_expr = nil, desc = nil, null: nil, field: nil, function: nil, deprecation_reason: nil, method: nil, connection: nil, max_page_size: nil, resolve: nil, &args_block)
         if !(field || function)
           if return_type_expr.nil?
-            raise ArgumentError "missing possitional argument `type`"
+            raise ArgumentError, "missing positional argument `type`"
           end
           if null.nil?
             raise ArgumentError, "missing keyword argument null:"
@@ -47,7 +47,8 @@ module GraphQL
         else
           GraphQL::Field.new
         end
-        field_defn.name = @name
+
+        field_defn.name = Member::BuildType.camelize(name)
 
         if @return_type_expr
           return_type_name = Member::BuildType.to_type_name(@return_type_expr)
@@ -96,6 +97,8 @@ module GraphQL
         field_defn
       end
 
+      private
+
       class << self
         def argument_class(new_arg_class = nil)
           if new_arg_class

data/lib/graphql/schema/input_object.rb

@@ -20,7 +20,7 @@ module GraphQL
         def argument(*args)
           argument = GraphQL::Schema::Argument.new(*args)
           own_arguments << argument
-          arg_name = argument.name
+          arg_name = argument.graphql_definition.name
           # Add a method access
           define_method(Member::BuildType.underscore(arg_name)) do
             @arguments.public_send(arg_name)
@@ -47,7 +47,7 @@ module GraphQL
           type_defn.name = graphql_name
           type_defn.description = description
           arguments.each do |arg|
-            type_defn.arguments[arg.name] = arg.graphql_definition
+            type_defn.arguments[arg.graphql_definition.name] = arg.graphql_definition
           end
           # Make a reference to a classic-style Arguments class
           self.arguments_class = GraphQL::Query::Arguments.construct_arguments_class(type_defn)

data/lib/graphql/schema/member.rb

@@ -62,6 +62,16 @@ module GraphQL
           end
         end
 
+        # Just a convenience method to point out that people should use graphql_name instead
+        def name(new_name = nil)
+          return super() if new_name.nil?
+
+          fail(
+            "The new name override method is `graphql_name`, not `name`. Usage: "\
+            "graphql_name \"#{new_name}\""
+          )
+        end
+
         # Call this method to provide a new description; OR
         # call it without an argument to get the description
         # @param new_description [String]

data/lib/graphql/schema/member/build_type.rb

@@ -94,6 +94,14 @@ module GraphQL
           end
         end
 
+        def camelize(string)
+          return string unless string.include?('_')
+
+          string.split('_').map(&:capitalize).join.tap do |camelized|
+            camelized[0] = camelized[0].downcase
+          end
+        end
+
         def underscore(string)
           string
             .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2') # URLDecoder -> URL_Decoder

data/lib/graphql/schema/member/instrumentation.rb

@@ -85,10 +85,10 @@ module GraphQL
           private
 
           def proxy_to_depth(obj, depth, type, ctx)
-            if depth > 0
-              obj.map { |inner_obj| proxy_to_depth(inner_obj, depth - 1, type, ctx) }
-            elsif obj.nil?
+            if obj.nil?
               obj
+            elsif depth > 0
+              obj.map { |inner_obj| proxy_to_depth(inner_obj, depth - 1, type, ctx) }
             else
               concrete_type = case type
               when GraphQL::UnionType, GraphQL::InterfaceType

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -62,19 +62,21 @@ module GraphQL
     class ActionCableSubscriptions < GraphQL::Subscriptions
       SUBSCRIPTION_PREFIX = "graphql-subscription:"
       EVENT_PREFIX = "graphql-event:"
-      def initialize(**rest)
+
+      # @param serializer [<#dump(obj), #load(string)] Used for serializing messages before handing them to `.broadcast(msg)`
+      def initialize(serializer: Serialize, **rest)
         # A per-process map of subscriptions to deliver.
         # This is provided by Rails, so let's use it
         @subscriptions = Concurrent::Map.new
+        @serializer = serializer
         super
       end
 
       # An event was triggered; Push the data over ActionCable.
       # Subscribers will re-evaluate locally.
-      # TODO: this method name is a smell
       def execute_all(event, object)
         stream = EVENT_PREFIX + event.topic
-        message = Serialize.dump(object)
+        message = @serializer.dump(object)
         ActionCable.server.broadcast(stream, message)
       end
 
@@ -97,7 +99,7 @@ module GraphQL
         @subscriptions[subscription_id] = query
         events.each do |event|
           channel.stream_from(EVENT_PREFIX + event.topic, coder: ActiveSupport::JSON) do |message|
-            execute(subscription_id, event, Serialize.load(message))
+            execute(subscription_id, event, @serializer.load(message))
             nil
           end
         end

data/lib/graphql/tracing.rb

@@ -2,6 +2,7 @@
 require "graphql/tracing/active_support_notifications_tracing"
 require "graphql/tracing/platform_tracing"
 require "graphql/tracing/appsignal_tracing"
+require "graphql/tracing/data_dog_tracing"
 require "graphql/tracing/new_relic_tracing"
 require "graphql/tracing/scout_tracing"
 require "graphql/tracing/skylight_tracing"

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -0,0 +1,45 @@
+# 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)
+        service = options.fetch(:service, 'ruby-graphql')
+
+        pin = Datadog::Pin.get_from(self)
+        unless pin
+          pin = Datadog::Pin.new(service)
+          pin.onto(self)
+        end
+
+        pin.tracer.trace(platform_key, service: pin.service) do |span|
+          if key == 'execute_multiplex'
+            span.resource = data[:multiplex].queries.map(&:selected_operation_name).join(', ')
+          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 platform_field_key(type, field)
+        "#{type.name}.#{field.name}"
+      end
+    end
+  end
+end