graphql 1.6.8 → 1.7.0

data/lib/graphql/field.rb

@@ -129,6 +129,7 @@ module GraphQL
       :edge_class,
       :relay_node_field,
       :relay_nodes_field,
+      :subscription_scope,
       argument: GraphQL::Define::AssignArgument
 
     ensure_defined(
@@ -136,7 +137,7 @@ module GraphQL
       :mutation, :arguments, :complexity, :function,
       :resolve, :resolve=, :lazy_resolve, :lazy_resolve=, :lazy_resolve_proc, :resolve_proc,
       :type, :type=, :name=, :property=, :hash_key=,
-      :relay_node_field, :relay_nodes_field, :edges?, :edge_class
+      :relay_node_field, :relay_nodes_field, :edges?, :edge_class, :subscription_scope
     )
 
     # @return [Boolean] True if this is the Relay find-by-id field
@@ -180,6 +181,9 @@ module GraphQL
 
     attr_writer :connection
 
+    # @return [nil, String] Prefix for subscription names from this field
+    attr_accessor :subscription_scope
+
     # @return [Boolean]
     def connection?
       @connection

data/lib/graphql/internal_representation/node.rb

@@ -145,6 +145,22 @@ module GraphQL
       # @return [GraphQL::Query]
       attr_reader :query
 
+      def subscription_topic
+        @subscription_topic ||= begin
+          scope = if definition.subscription_scope
+            @query.context[definition.subscription_scope]
+          else
+            nil
+          end
+          Subscriptions::Event.serialize(
+            definition_name,
+            @query.arguments_for(self, definition),
+            definition,
+            scope: scope
+          )
+        end
+      end
+
       protected
 
       attr_writer :owner_type, :parent

data/lib/graphql/invalid_name_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module GraphQL
+  class InvalidNameError < GraphQL::ExecutionError
+    attr_reader :name, :valid_regex
+    def initialize(name, valid_regex)
+      @name = name
+      @valid_regex = valid_regex
+      super("Names must match #{@valid_regex.inspect} but '#{@name}' does not")
+    end
+  end
+end

data/lib/graphql/language/parser.rb

@@ -21,11 +21,17 @@ end
 
 def parse_document
   @document ||= begin
-    @tokens ||= GraphQL.scan(@query_string)
-    if @tokens.none?
-      make_node(:Document, definitions: [], filename: @filename)
-    else
-      do_parse
+    # Break the string into tokens
+    GraphQL::Tracing.trace("lex", {query_string: @query_string}) do
+      @tokens ||= GraphQL.scan(@query_string)
+    end
+    # From the tokens, build an AST
+    GraphQL::Tracing.trace("parse", {query_string: @query_string}) do
+      if @tokens.none?
+        make_node(:Document, definitions: [], filename: @filename)
+      else
+        do_parse
+      end
     end
   end
 end

data/lib/graphql/language/parser.y

@@ -361,11 +361,17 @@ end
 
 def parse_document
   @document ||= begin
-    @tokens ||= GraphQL.scan(@query_string)
-    if @tokens.none?
-      make_node(:Document, definitions: [], filename: @filename)
-    else
-      do_parse
+    # Break the string into tokens
+    GraphQL::Tracing.trace("lex", {query_string: @query_string}) do
+      @tokens ||= GraphQL.scan(@query_string)
+    end
+    # From the tokens, build an AST
+    GraphQL::Tracing.trace("parse", {query_string: @query_string}) do
+      if @tokens.none?
+        make_node(:Document, definitions: [], filename: @filename)
+      else
+        do_parse
+      end
     end
   end
 end

data/lib/graphql/name_validator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module GraphQL
+  class NameValidator
+    VALID_NAME_REGEX = /^[_a-zA-Z][_a-zA-Z0-9]*$/
+
+    def self.validate!(name)
+      raise GraphQL::InvalidNameError.new(name, VALID_NAME_REGEX) unless valid?(name)
+    end
+
+    private
+
+    def self.valid?(name)
+      name =~ VALID_NAME_REGEX
+    end
+  end
+end

data/lib/graphql/object_type.rb

@@ -102,6 +102,11 @@ module GraphQL
       dirty_ifaces.concat(interfaces)
     end
 
+    def name=(name)
+      GraphQL::NameValidator.validate!(name)
+      @name = name
+    end
+
     protected
 
     attr_reader :dirty_interfaces, :dirty_inherited_interfaces

data/lib/graphql/query.rb

@@ -5,6 +5,7 @@ require "graphql/query/context"
 require "graphql/query/executor"
 require "graphql/query/literal_input"
 require "graphql/query/null_context"
+require "graphql/query/result"
 require "graphql/query/serial_execution"
 require "graphql/query/variables"
 require "graphql/query/input_validation_result"
@@ -48,6 +49,12 @@ module GraphQL
       selected_operation.name
     end
 
+    # @return [String, nil] the triggered event, if this query is a subscription update
+    attr_reader :subscription_topic
+
+    # @return [String, nil]
+    attr_reader :operation_name
+
     # Prepare query `query_string` on `schema`
     # @param schema [GraphQL::Schema]
     # @param query_string [String]
@@ -59,10 +66,11 @@ module GraphQL
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
     # @param except [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns truthy
     # @param only [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns false
-    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: {}, validate: true, operation_name: nil, root_value: nil, max_depth: nil, max_complexity: nil, except: nil, only: nil)
+    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: {}, validate: true, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: nil, max_complexity: nil, except: nil, only: nil)
       @schema = schema
       @filter = schema.default_filter.merge(except: except, only: only)
-      @context = Context.new(query: self, values: context)
+      @context = Context.new(query: self, object: root_value, values: context)
+      @subscription_topic = subscription_topic
       @root_value = root_value
       @fragments = nil
       @operations = nil
@@ -78,6 +86,10 @@ module GraphQL
       @query_string = query_string || query
       @document = document
 
+      if @query_string && @document
+        raise ArgumentError, "Query should only be provided a query string or a document, not both."
+      end
+
       # A two-layer cache of type resolution:
       # { abstract_type => { value => resolved_type } }
       @resolved_types_cache = Hash.new do |h1, k1|
@@ -94,22 +106,25 @@ module GraphQL
       @mutation = false
       @operation_name = operation_name
       @prepared_ast = false
-
       @validation_pipeline = nil
       @max_depth = max_depth || schema.max_depth
       @max_complexity = max_complexity || schema.max_complexity
 
-      @result = nil
+      @result_values = nil
       @executed = false
     end
 
+    def subscription_update?
+      @subscription_topic && subscription?
+    end
+
     # @api private
-    def result=(result_hash)
+    def result_values=(result_hash)
       if @executed
         raise "Invariant: Can't reassign result"
       else
         @executed = true
-        @result = result_hash
+        @result_values = result_hash
       end
     end
 
@@ -129,7 +144,7 @@ module GraphQL
           Execution::Multiplex.run_queries(@schema, [self])
         }
       end
-      @result
+      @result ||= Query::Result.new(query: self, values: @result_values)
     end
 
     def static_errors
@@ -228,6 +243,10 @@ module GraphQL
       nil
     end
 
+    def subscription?
+      with_prepared_ast { @subscription }
+    end
+
     private
 
     def find_operation(operations, operation_name)
@@ -277,6 +296,7 @@ module GraphQL
       # with no operations returns an empty hash
       @ast_variables = []
       @mutation = false
+      @subscription = false
       operation_name_error = nil
       if @operations.any?
         @selected_operation = find_operation(@operations, @operation_name)
@@ -289,6 +309,7 @@ module GraphQL
           @ast_variables = @selected_operation.variables
           @mutation = @selected_operation.operation_type == "mutation"
           @query = @selected_operation.operation_type == "query"
+          @subscription = @selected_operation.operation_type == "subscription"
         end
       end
 

data/lib/graphql/query/context.rb

@@ -1,10 +1,80 @@
 # frozen_string_literal: true
+# test_via: ../execution/execute.rb
+# test_via: ../execution/lazy.rb
 module GraphQL
   class Query
     # Expose some query-specific info to field resolve functions.
     # It delegates `[]` to the hash that's passed to `GraphQL::Query#initialize`.
     class Context
+      module SharedMethods
+        # @return [Object] The target for field resultion
+        attr_accessor :object
+
+        # @return [Hash, Array, String, Integer, Float, Boolean, nil] The resolved value for this field
+        attr_reader :value
+
+        # @return [Boolean] were any fields of this selection skipped?
+        attr_reader :skipped
+        alias :skipped? :skipped
+
+        # @api private
+        attr_writer :skipped
+
+        # Return this value to tell the runtime
+        # to exclude this field from the response altogether
+        def skip
+          GraphQL::Execution::Execute::SKIP
+        end
+
+        # @return [Boolean] True if this selection has been nullified by a null child
+        def invalid_null?
+          @invalid_null
+        end
+
+        # Remove this child from the result value
+        # (used for null propagation and skip)
+        # @api private
+        def delete(child_ctx)
+          @value.delete(child_ctx.key)
+        end
+
+        # Create a child context to use for `key`
+        # @param key [String, Integer] The key in the response (name or index)
+        # @param irep_node [InternalRepresentation::Node] The node being evaluated
+        # @api private
+        def spawn_child(key:, irep_node:, object:)
+          FieldResolutionContext.new(
+            context: @context,
+            parent: self,
+            object: object,
+            key: key,
+            irep_node: irep_node,
+          )
+        end
+
+        # Add error at query-level.
+        # @param error [GraphQL::ExecutionError] an execution error
+        # @return [void]
+        def add_error(error)
+          if !error.is_a?(ExecutionError)
+            raise TypeError, "expected error to be a ExecutionError, but was #{error.class}"
+          end
+          errors << error
+          nil
+        end
+
+        # @example Print the GraphQL backtrace during field resolution
+        #   puts ctx.backtrace
+        #
+        # @return [GraphQL::Backtrace] The backtrace for this point in query execution
+        def backtrace
+          GraphQL::Backtrace.new(self)
+        end
+      end
+
+      include SharedMethods
       extend GraphQL::Delegate
+
       attr_reader :execution_strategy
       # `strategy` is required by GraphQL::Batch
       alias_method :strategy, :execution_strategy
@@ -17,7 +87,9 @@ module GraphQL
       end
 
       # @return [GraphQL::InternalRepresentation::Node] The internal representation for this query node
-      attr_accessor :irep_node
+      def irep_node
+        @irep_node ||= query.irep_selection
+      end
 
       # @return [GraphQL::Language::Nodes::Field] The AST node for the currently-executing field
       def ast_node
@@ -39,17 +111,23 @@ module GraphQL
       # Make a new context which delegates key lookup to `values`
       # @param query [GraphQL::Query] the query who owns this context
       # @param values [Hash] A hash of arbitrary values which will be accessible at query-time
-      def initialize(query:, values:)
+      def initialize(query:, values: , object:)
         @query = query
         @schema = query.schema
         @provided_values = values || {}
+        @object = object
         # Namespaced storage, where user-provided values are in `nil` namespace:
         @storage = Hash.new { |h, k| h[k] = {} }
         @storage[nil] = @provided_values
         @errors = []
         @path = []
+        @value = nil
+        @context = self # for SharedMethods
       end
 
+      # @api private
+      attr_writer :value
+
       def_delegators :@provided_values, :[], :[]=, :to_h, :key?, :fetch
 
       # @!method [](key)
@@ -58,6 +136,7 @@ module GraphQL
       # @!method []=(key, value)
       #   Reassign `key` to the hash passed to {Schema#execute} as `context:`
 
+
       # @return [GraphQL::Schema::Warden]
       def warden
         @warden ||= @query.warden
@@ -70,46 +149,32 @@ module GraphQL
         @storage[ns]
       end
 
-      def spawn(key:, selection:, parent_type:, field:)
-        FieldResolutionContext.new(
-          context: self,
-          parent: self,
-          key: key,
-          selection: selection,
-          parent_type: parent_type,
-          field: field,
-        )
+      def inspect
+        "#<Query::Context ...>"
       end
 
-      # Return this value to tell the runtime
-      # to exclude this field from the response altogether
-      def skip
-        GraphQL::Execution::Execute::SKIP
-      end
-
-      # Add error at query-level.
-      # @param error [GraphQL::ExecutionError] an execution error
-      # @return [void]
-      def add_error(error)
-        if !error.is_a?(ExecutionError)
-          raise TypeError, "expected error to be a ExecutionError, but was #{error.class}"
-        end
-        errors << error
-        nil
+      # @api private
+      def received_null_child
+        @invalid_null = true
+        @value = nil
       end
 
       class FieldResolutionContext
+        include SharedMethods
         extend GraphQL::Delegate
 
-        attr_reader :selection, :field, :parent_type, :query, :schema
+        attr_reader :irep_node, :field, :parent_type, :query, :schema, :parent, :key, :type
+        alias :selection :irep_node
 
-        def initialize(context:, key:, selection:, parent:, field:, parent_type:)
+        def initialize(context:, key:, irep_node:, parent:, object:)
           @context = context
           @key = key
           @parent = parent
-          @selection = selection
-          @field = field
-          @parent_type = parent_type
+          @object = object
+          @irep_node = irep_node
+          @field = irep_node.definition
+          @parent_type = irep_node.owner_type
+          @type = field.type
           # This is needed constantly, so set it ahead of time:
           @query = context.query
           @schema = context.schema
@@ -122,41 +187,79 @@ module GraphQL
         def_delegators :@context,
           :[], :[]=, :key?, :fetch, :to_h, :namespace,
           :spawn, :schema, :warden, :errors,
-          :execution_strategy, :strategy, :skip
+          :execution_strategy, :strategy
 
         # @return [GraphQL::Language::Nodes::Field] The AST node for the currently-executing field
         def ast_node
-          @selection.ast_node
-        end
-
-        # @return [GraphQL::InternalRepresentation::Node]
-        def irep_node
-          @selection
+          @irep_node.ast_node
         end
 
         # Add error to current field resolution.
         # @param error [GraphQL::ExecutionError] an execution error
         # @return [void]
         def add_error(error)
-          if !error.is_a?(ExecutionError)
-            raise TypeError, "expected error to be a ExecutionError, but was #{error.class}"
-          end
-
+          super
           error.ast_node ||= irep_node.ast_node
           error.path ||= path
-          errors << error
           nil
         end
 
-        def spawn(key:, selection:, parent_type:, field:)
-          FieldResolutionContext.new(
-            context: @context,
-            parent: self,
-            key: key,
-            selection: selection,
-            parent_type: parent_type,
-            field: field,
-          )
+        def inspect
+          "#<GraphQL Context @ #{irep_node.owner_type.name}.#{field.name}>"
+        end
+
+        # Set a new value for this field in the response.
+        # It may be updated after resolving a {Lazy}.
+        # If it is {Execute::PROPAGATE_NULL}, tell the owner to propagate null.
+        # If it's {Execute::Execution::SKIP}, remove this field result from its parent
+        # @param new_value [Any] The GraphQL-ready value
+        # @api private
+        def value=(new_value)
+          case new_value
+          when GraphQL::Execution::Execute::PROPAGATE_NULL, nil
+            @invalid_null = true
+            @value = nil
+            if @type.kind.non_null?
+              @parent.received_null_child
+            end
+          when GraphQL::Execution::Execute::SKIP
+            @parent.skipped = true
+            @parent.delete(self)
+          else
+            @value = new_value
+          end
+        end
+
+        protected
+
+        def received_null_child
+          case @value
+          when Hash
+            self.value = GraphQL::Execution::Execute::PROPAGATE_NULL
+          when Array
+            if list_of_non_null_items?(@type)
+              self.value = GraphQL::Execution::Execute::PROPAGATE_NULL
+            end
+          when nil
+            # TODO This is a hack
+            # It was already nulled out but it's getting reassigned
+          else
+            raise "Unexpected value for received_null_child (#{self.value.class}): #{value}"
+          end
+        end
+
+        private
+
+        def list_of_non_null_items?(type)
+          case type
+          when GraphQL::NonNullType
+            # Unwrap [T]!
+            list_of_non_null_items?(type.of_type)
+          when GraphQL::ListType
+            type.of_type.is_a?(GraphQL::NonNullType)
+          else
+            raise "Unexpected list_of_non_null_items check: #{type}"
+          end
         end
       end
     end