graphql 1.8.0.pre4 → 1.8.0.pre5

data/lib/graphql/language/lexer.rl

@@ -34,6 +34,9 @@
   RBRACKET =      ']';
   COLON =         ':';
   QUOTE =         '"';
+  BLOCK_QUOTE =   '"""';
+  ESCAPED_BLOCK_QUOTE = '\\"""';
+  BLOCK_STRING_CHAR = (ESCAPED_BLOCK_QUOTE | ^'"""');
   ESCAPED_QUOTE = '\\"';
   STRING_CHAR =   (ESCAPED_QUOTE | ^'"');
   VAR_SIGN =      '$';
@@ -44,7 +47,7 @@
   PIPE =          '|';
 
   QUOTED_STRING = QUOTE STRING_CHAR* QUOTE;
-
+  BLOCK_STRING = BLOCK_QUOTE BLOCK_STRING_CHAR* BLOCK_QUOTE;
   # catch-all for anything else. must be at the bottom for precedence.
   UNKNOWN_CHAR =         /./;
 
@@ -75,7 +78,8 @@
     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, meta) };
+    QUOTED_STRING => { emit_string(ts, te, meta, block: false) };
+    BLOCK_STRING  => { emit_string(ts, te, meta, block: true) };
     VAR_SIGN      => { emit(:VAR_SIGN, ts, te, meta) };
     DIR_SIGN      => { emit(:DIR_SIGN, ts, te, meta) };
     ELLIPSIS      => { emit(:ELLIPSIS, ts, te, meta) };
@@ -188,8 +192,13 @@ module GraphQL
       PACK_DIRECTIVE = "c*"
       UTF_8_ENCODING = "UTF-8"
 
-      def self.emit_string(ts, te, meta)
-        value = meta[:data][ts...te - 1].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING)
+      def self.emit_string(ts, te, meta, block:)
+        quotes_length = block ? 3 : 1
+        ts += quotes_length
+        value = meta[:data][ts...te - quotes_length].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING)
+        if block
+          value = GraphQL::Language::BlockString.trim_whitespace(value)
+        end
         if value !~ VALID_STRING
           meta[:tokens] << token = GraphQL::Language::Token.new(
             name: :BAD_UNICODE_ESCAPE,

data/lib/graphql/language/nodes.rb

@@ -288,13 +288,16 @@ module GraphQL
         private
 
         def serialize_value_for_hash(value)
-          if value.is_a? InputObject
+          case value
+          when InputObject
             value.to_h
-          elsif value.is_a? Array
+          when Array
             value.map do |v|
               serialize_value_for_hash v
             end
-          elsif value.is_a? NullValue
+          when Enum
+            value.name
+          when NullValue
             nil
           else
             value

data/lib/graphql/language/printer.rb

@@ -93,7 +93,7 @@ module GraphQL
       end
 
       def print_input_object(input_object)
-        print_node(input_object.to_h)
+        "{#{input_object.arguments.map { |a| "#{a.name}: #{print(a.value)}" }.join(", ")}}"
       end
 
       def print_list_type(list_type)

data/lib/graphql/language/token.rb

@@ -12,7 +12,7 @@ module GraphQL
 
       def initialize(value:, name:, line:, col:, prev_token:)
         @name = name
-        @value = value
+        @value = value.freeze
         @line = line
         @col = col
         @prev_token = prev_token

data/lib/graphql/query.rb

@@ -160,7 +160,7 @@ module GraphQL
     def result
       if !@executed
         with_prepared_ast {
-          Execution::Multiplex.run_queries(@schema, [self])
+          Execution::Multiplex.run_queries(@schema, [self], context: @context)
         }
       end
       @result ||= Query::Result.new(query: self, values: @result_values)

data/lib/graphql/relay.rb

@@ -15,3 +15,4 @@ require 'graphql/relay/node'
 require 'graphql/relay/connection_instrumentation'
 require 'graphql/relay/connection_resolve'
 require 'graphql/relay/connection_type'
+require 'graphql/relay/type_extensions'

data/lib/graphql/relay/connection_type.rb

@@ -13,15 +13,17 @@ module GraphQL
       self.bidirectional_pagination = false
 
       # Create a connection which exposes edges of this type
-      def self.create_type(wrapped_type, edge_type: wrapped_type.edge_type, edge_class: GraphQL::Relay::Edge, nodes_field: ConnectionType.default_nodes_field, &block)
+      def self.create_type(wrapped_type, edge_type: nil, edge_class: GraphQL::Relay::Edge, nodes_field: ConnectionType.default_nodes_field, &block)
         custom_edge_class = edge_class
 
         # Any call that would trigger `wrapped_type.ensure_defined`
         # must be inside this lazy block, otherwise we get weird
         # cyclical dependency errors :S
         ObjectType.define do
-          name("#{wrapped_type.name}Connection")
-          description("The connection type for #{wrapped_type.name}.")
+          type_name = wrapped_type.is_a?(GraphQL::BaseType) ? wrapped_type.name : wrapped_type.graphql_name
+          edge_type ||= wrapped_type.edge_type
+          name("#{type_name}Connection")
+          description("The connection type for #{type_name}.")
           field :edges, types[edge_type], "A list of edges.", edge_class: custom_edge_class, property: :edge_nodes
 
           if nodes_field

data/lib/graphql/relay/edge_type.rb

@@ -4,7 +4,8 @@ module GraphQL
     module EdgeType
       def self.create_type(wrapped_type, name: nil, &block)
         GraphQL::ObjectType.define do
-          name("#{wrapped_type.name}Edge")
+          type_name = wrapped_type.is_a?(GraphQL::BaseType) ? wrapped_type.name : wrapped_type.graphql_name
+          name("#{type_name}Edge")
           description "An edge in a connection."
           field :node, wrapped_type, "The item at the end of the edge."
           field :cursor, !types.String, "A cursor for use in pagination."

data/lib/graphql/relay/type_extensions.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    # Mixin for Relay-related methods in type objects
+    # (used by BaseType and Schema::Member).
+    module TypeExtensions
+      # @return [GraphQL::ObjectType] The default connection type for this object type
+      def connection_type
+        @connection_type ||= define_connection
+      end
+
+      # Define a custom connection type for this object type
+      # @return [GraphQL::ObjectType]
+      def define_connection(**kwargs, &block)
+        GraphQL::Relay::ConnectionType.create_type(self, **kwargs, &block)
+      end
+
+      # @return [GraphQL::ObjectType] The default edge type for this object type
+      def edge_type
+        @edge_type ||= define_edge
+      end
+
+      # Define a custom edge type for this object type
+      # @return [GraphQL::ObjectType]
+      def define_edge(**kwargs, &block)
+        GraphQL::Relay::EdgeType.create_type(self, **kwargs, &block)
+      end
+    end
+  end
+end

data/lib/graphql/schema.rb

@@ -3,6 +3,7 @@ require "graphql/schema/base_64_encoder"
 require "graphql/schema/catchall_middleware"
 require "graphql/schema/default_parse_error"
 require "graphql/schema/default_type_error"
+require "graphql/schema/finder"
 require "graphql/schema/invalid_type_error"
 require "graphql/schema/introspection_system"
 require "graphql/schema/late_bound_type"
@@ -329,6 +330,19 @@ module GraphQL
       }
     end
 
+    # Search for a schema member using a string path
+    # @example Finding a Field
+    # Schema.find("Ensemble.musicians")
+    #
+    # @see {GraphQL::Schema::Finder} for more examples
+    # @param path [String] A dot-separated path to the member
+    # @raise [Schema::Finder::MemberNotFoundError] if path could not be found
+    # @return [GraphQL::BaseType, GraphQL::Field, GraphQL::Argument, GraphQL::Directive] A GraphQL Schema Member
+    def find(path)
+      rebuild_artifacts unless defined?(@finder)
+      @find_cache[path] ||= @finder.find(path)
+    end
+
     # Resolve field named `field_name` for type `parent_type`.
     # Handles dynamic fields `__typename`, `__type` and `__schema`, too
     # @param parent_type [String, GraphQL::BaseType]
@@ -641,6 +655,7 @@ module GraphQL
         schema_defn.query = query
         schema_defn.mutation = mutation
         schema_defn.subscription = subscription
+        schema_defn.max_complexity = max_complexity
         schema_defn.max_depth = max_depth
         schema_defn.default_max_page_size = default_max_page_size
         schema_defn.orphan_types = orphan_types
@@ -720,6 +735,14 @@ module GraphQL
         end
       end
 
+      def max_complexity(max_complexity = nil)
+        if max_complexity
+          @max_complexity = max_complexity
+        else
+          @max_complexity
+        end
+      end
+
       def max_depth(new_max_depth = nil)
         if new_max_depth
           @max_depth = new_max_depth
@@ -846,6 +869,8 @@ module GraphQL
         @instrumented_field_map = traversal.instrumented_field_map
         @type_reference_map = traversal.type_reference_map
         @union_memberships = traversal.union_memberships
+        @find_cache = {}
+        @finder = Finder.new(self)
       end
     ensure
       @rebuilding_artifacts = false

data/lib/graphql/schema/build_from_definition.rb

@@ -193,6 +193,8 @@ module GraphQL
             nil
           when GraphQL::Language::Nodes::InputObject
             default_value.to_h
+          when Array
+            default_value.map { |v| build_default_value(v) }
           else
             default_value
           end

data/lib/graphql/schema/field.rb

@@ -16,6 +16,9 @@ module GraphQL
       # @return [Hash{String => GraphQL::Schema::Argument}]
       attr_reader :arguments
 
+      # @return [Symbol]
+      attr_reader :method
+
       def initialize(name, return_type_expr = nil, desc = nil, null: nil, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, connection: nil, max_page_size: nil, resolve: nil, introspection: false, extras: [], &definition_block)
         if !(field || function)
           if return_type_expr.nil?

data/lib/graphql/schema/finder.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # Find schema members using string paths
+    #
+    # @example Finding object types
+    # MySchema.find("SomeObjectType")
+    #
+    # @example Finding fields
+    # MySchema.find("SomeObjectType.myField")
+    #
+    # @example Finding arguments
+    # MySchema.find("SomeObjectType.myField.anArgument")
+    #
+    # @example Finding directives
+    # MySchema.find("@include")
+    #
+    class Finder
+      class MemberNotFoundError < ArgumentError; end
+
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def find(path)
+        path = path.split(".")
+        type_or_directive = path.shift
+
+        if type_or_directive.start_with?("@")
+          directive = schema.directives[type_or_directive[1..-1]]
+
+          if directive.nil?
+            raise MemberNotFoundError, "Could not find directive `#{type_or_directive}` in schema."
+          end
+
+          return directive if path.empty?
+
+          find_in_directive(directive, path: path)
+        else
+          type = schema.types[type_or_directive]
+
+          if type.nil?
+            raise MemberNotFoundError, "Could not find type `#{type_or_directive}` in schema."
+          end
+
+          return type if path.empty?
+
+          find_in_type(type, path: path)
+        end
+      end
+
+      private
+
+      attr_reader :schema
+
+      def find_in_directive(directive, path:)
+        argument_name = path.shift
+        argument = directive.arguments[argument_name]
+
+        if argument.nil?
+          raise MemberNotFoundError, "Could not find argument `#{argument_name}` on directive #{directive}."
+        end
+
+        argument
+      end
+
+      def find_in_type(type, path:)
+        case type
+        when GraphQL::ObjectType
+          find_in_fields_type(type, kind: "object", path: path)
+        when GraphQL::InterfaceType
+          find_in_fields_type(type, kind: "interface", path: path)
+        when GraphQL::InputObjectType
+          find_in_input_object(type, path: path)
+        when GraphQL::UnionType
+          # Error out if path that was provided is too long
+          # i.e UnionType.PossibleType.aField
+          # Use PossibleType.aField instead.
+          if invalid = path.first
+            raise MemberNotFoundError, "Cannot select union possible type `#{invalid}`. Select the type directly instead."
+          end
+        when GraphQL::EnumType
+          find_in_enum_type(type, path: path)
+        end
+      end
+
+      def find_in_fields_type(type, kind:, path:)
+        field_name = path.shift
+        field = schema.get_field(type, field_name)
+
+        if field.nil?
+          raise MemberNotFoundError, "Could not find field `#{field_name}` on #{kind} type `#{type}`."
+        end
+
+        return field if path.empty?
+
+        find_in_field(field, path: path)
+      end
+
+      def find_in_field(field, path:)
+        argument_name = path.shift
+        argument = field.arguments[argument_name]
+
+        if argument.nil?
+          raise MemberNotFoundError, "Could not find argument `#{argument_name}` on field `#{field.name}`."
+        end
+
+        # Error out if path that was provided is too long
+        # i.e Type.field.argument.somethingBad
+        if invalid = path.first
+          raise MemberNotFoundError, "Cannot select member `#{invalid}` on a field."
+        end
+
+        argument
+      end
+
+      def find_in_input_object(input_object, path:)
+        field_name = path.shift
+        input_field = input_object.input_fields[field_name]
+
+        if input_field.nil?
+          raise MemberNotFoundError, "Could not find input field `#{field_name}` on input object type `#{input_object}`."
+        end
+
+        # Error out if path that was provided is too long
+        # i.e InputType.inputField.bad
+        if invalid = path.first
+          raise MemberNotFoundError, "Cannot select member `#{invalid}` on an input field."
+        end
+
+        input_field
+      end
+
+      def find_in_enum_type(enum_type, path:)
+        value_name = path.shift
+        enum_value = enum_type.values[value_name]
+
+        if enum_value.nil?
+          raise MemberNotFoundError, "Could not find enum value `#{value_name}` on enum type `#{enum_type}`."
+        end
+
+        # Error out if path that was provided is too long
+        # i.e Enum.VALUE.wat
+        if invalid = path.first
+          raise MemberNotFoundError, "Cannot select member `#{invalid}` on an enum value."
+        end
+
+        enum_value
+      end
+    end
+  end
+end

data/lib/graphql/schema/member.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+require "graphql/relay/type_extensions"
+
 module GraphQL
   # The base class for things that make up the schema,
   # eg objects, enums, scalars.
@@ -35,7 +37,7 @@ module GraphQL
       include GraphQLTypeNames
       class << self
         include CachedGraphQLDefinition
-
+        include GraphQL::Relay::TypeExtensions
         # Delegate to the derived type definition if possible.
         # This is tricky because missing methods cause the definition to be built & cached.
         def method_missing(method_name, *args, &block)

data/lib/graphql/schema/printer.rb

@@ -100,7 +100,7 @@ module GraphQL
           if reason.value == GraphQL::Directive::DEFAULT_DEPRECATION_REASON
             "@deprecated"
           else
-            "@deprecated(reason: \"#{reason.value}\")"
+            "@deprecated(reason: #{reason.value.to_s.inspect})"
           end
         else
           super

data/lib/graphql/static_validation/rules/fields_will_merge.rb

@@ -2,6 +2,9 @@
 module GraphQL
   module StaticValidation
     class FieldsWillMerge
+      # Special handling for fields without arguments
+      NO_ARGS = {}.freeze
+
       def validate(context)
         context.each_irep_node do |node|
           if node.ast_nodes.size > 1
@@ -16,15 +19,19 @@ module GraphQL
 
             # Check for incompatible / non-identical arguments on this node:
             args = node.ast_nodes.map do |n|
-              n.arguments.reduce({}) do |memo, a|
-                arg_value = a.value
-                memo[a.name] = case arg_value
-                when GraphQL::Language::Nodes::AbstractNode
-                  arg_value.to_query_string
-                else
-                  GraphQL::Language.serialize(arg_value)
+              if n.arguments.any?
+                n.arguments.reduce({}) do |memo, a|
+                  arg_value = a.value
+                  memo[a.name] = case arg_value
+                  when GraphQL::Language::Nodes::AbstractNode
+                    arg_value.to_query_string
+                  else
+                    GraphQL::Language.serialize(arg_value)
+                  end
+                  memo
                 end
-                memo
+              else
+                NO_ARGS
               end
             end
             args.uniq!