graphql 1.6.8 → 1.7.0

data/lib/graphql/query/literal_input.rb

@@ -14,9 +14,22 @@ module GraphQL
         else
           case type
           when GraphQL::ScalarType
-            type.coerce_input(ast_node, variables.context)
+            # TODO smell
+            # This gets used for plain values during subscriber.trigger
+            if variables
+              type.coerce_input(ast_node, variables.context)
+            else
+              type.coerce_isolated_input(ast_node)
+            end
           when GraphQL::EnumType
-            type.coerce_input(ast_node.name, variables.context)
+            # TODO smell
+            # This gets used for plain values sometimes
+            v = ast_node.is_a?(GraphQL::Language::Nodes::Enum) ? ast_node.name : ast_node
+            if variables
+              type.coerce_input(v, variables.context)
+            else
+              type.coerce_isolated_input(v)
+            end
           when GraphQL::NonNullType
             LiteralInput.coerce(type.of_type, ast_node, variables)
           when GraphQL::ListType
@@ -26,7 +39,9 @@ module GraphQL
               [LiteralInput.coerce(type.of_type, ast_node, variables)]
             end
           when GraphQL::InputObjectType
-            from_arguments(ast_node.arguments, type.arguments, variables)
+            # TODO smell: handling AST vs handling plain Ruby
+            next_args = ast_node.is_a?(Hash) ? ast_node : ast_node.arguments
+            from_arguments(next_args, type.arguments, variables)
           end
         end
       end
@@ -43,7 +58,14 @@ module GraphQL
         # Variables is nil when making .defaults_for
         context = variables ? variables.context : nil
         values_hash = {}
-        indexed_arguments = ast_arguments.each_with_object({}) { |a, memo| memo[a.name] = a }
+        indexed_arguments = case ast_arguments
+        when Hash
+          ast_arguments
+        when Array
+          ast_arguments.each_with_object({}) { |a, memo| memo[a.name] = a }
+        else
+          raise ArgumentError, "Unexpected ast_arguments: #{ast_arguments}"
+        end
 
         argument_defns.each do |arg_name, arg_defn|
           ast_arg = indexed_arguments[arg_name]
@@ -51,12 +73,17 @@ module GraphQL
           # If the value is a variable,
           # only add a value if the variable is actually present.
           # Otherwise, coerce the value in the AST, prepare the value and add it.
-          if ast_arg
-            value_is_a_variable = ast_arg.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+          #
+          # TODO: since indexed_arguments can come from a plain Ruby hash,
+          # have to check for `false` or `nil` as hash values. This is getting smelly :S
+          if indexed_arguments.key?(arg_name)
+            arg_value = ast_arg.is_a?(GraphQL::Language::Nodes::Argument) ? ast_arg.value : ast_arg
+
+            value_is_a_variable = arg_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
 
-            if (!value_is_a_variable || (value_is_a_variable && variables.key?(ast_arg.value.name)))
+            if (!value_is_a_variable || (value_is_a_variable && variables.key?(arg_value.name)))
 
-              value = coerce(arg_defn.type, ast_arg.value, variables)
+              value = coerce(arg_defn.type, arg_value, variables)
               value = arg_defn.prepare(value, context)
 
               if value.is_a?(GraphQL::ExecutionError)
@@ -64,7 +91,7 @@ module GraphQL
                 raise value
               end
 
-              values_hash[ast_arg.name] = value
+              values_hash[arg_name] = value
             end
           end
 

data/lib/graphql/query/null_context.rb

@@ -3,12 +3,18 @@ module GraphQL
   class Query
     # This object can be `ctx` in places where there is no query
     class NullContext
+      class NullWarden < GraphQL::Schema::Warden
+        def visible?(t); true; end
+        def visible_field?(t); true; end
+        def visible_type?(t); true; end
+      end
+
       attr_reader :schema, :query, :warden
 
       def initialize
         @query = nil
         @schema = GraphQL::Schema.new
-        @warden = GraphQL::Schema::Warden.new(
+        @warden = NullWarden.new(
           GraphQL::Filter.new,
           context: self,
           schema: @schema,

data/lib/graphql/query/result.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Query
+    # A result from {Schema#execute}.
+    # It provides the requested data and
+    # access to the {Query} and {Query::Context}.
+    class Result
+      extend GraphQL::Delegate
+
+      def initialize(query:, values:)
+        @query = query
+        @to_h = values
+      end
+
+      # @return [GraphQL::Query] The query that was executed
+      attr_reader :query
+
+      # @return [Hash] The resulting hash of "data" and/or "errors"
+      attr_reader :to_h
+
+      def_delegators :@query, :context, :mutation?, :query?, :subscription?
+
+      def_delegators :@to_h, :[], :keys, :values, :to_json, :as_json
+
+      # Delegate any hash-like method to the underlying hash.
+      def method_missing(method_name, *args, &block)
+        if @to_h.respond_to?(method_name)
+          @to_h.public_send(method_name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @to_h.respond_to?(method_name) || super
+      end
+
+      def inspect
+        "#<GraphQL::Query::Result @query=... @to_h=#{@to_h} >"
+      end
+
+      # A result is equal to another object when:
+      #
+      # - The other object is a Hash whose value matches `result.to_h`
+      # - The other object is a Result whose value matches `result.to_h`
+      #
+      # (The query is ignored for comparing result equality.)
+      #
+      # @return [Boolean]
+      def ==(other)
+        case other
+        when Hash
+          @to_h == other
+        when Query::Result
+          @to_h == other.to_h
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/graphql/query/serial_execution/field_resolution.rb

@@ -12,11 +12,10 @@ module GraphQL
           @target = target
           @query = query_ctx.query
           @field = irep_node.definition
-          @field_ctx = query_ctx.spawn(
+          @field_ctx = query_ctx.spawn_child(
             key: irep_node.name,
-            selection: selection,
-            parent_type: parent_type,
-            field: field,
+            object: target,
+            irep_node: irep_node,
           )
           @arguments = @query.arguments_for(irep_node, @field)
         end

data/lib/graphql/query/serial_execution/value_resolution.rb

@@ -23,11 +23,10 @@ module GraphQL
               result = []
               i = 0
               value.each do |inner_value|
-                inner_ctx = query_ctx.spawn(
+                inner_ctx = query_ctx.spawn_child(
                   key: i,
-                  selection: selection,
-                  parent_type: wrapped_type,
-                  field: field_defn,
+                  object: inner_value,
+                  irep_node: selection,
                 )
 
                 result << resolve(

data/lib/graphql/query/variables.rb

@@ -44,7 +44,7 @@ module GraphQL
         end
       end
 
-      def_delegators :@storage, :length, :key?, :[], :fetch
+      def_delegators :@storage, :length, :key?, :[], :fetch, :to_h
     end
   end
 end

data/lib/graphql/schema.rb

@@ -81,6 +81,10 @@ module GraphQL
       :cursor_encoder,
       :raise_definition_error
 
+    # Single, long-lived instance of the provided subscriptions class, if there is one.
+    # @return [GraphQL::Subscriptions]
+    attr_accessor :subscriptions
+
     # @return [MiddlewareChain] MiddlewareChain which is applied to fields during execution
     attr_accessor :middleware
 
@@ -212,6 +216,14 @@ module GraphQL
       end
     end
 
+    # @return [Array<GraphQL::BaseType>] The root types of this schema
+    def root_types
+      @root_types ||= begin
+        rebuild_artifacts
+        @root_types
+      end
+    end
+
     # @see [GraphQL::Schema::Warden] Restricted access to members of a schema
     # @return [GraphQL::Schema::TypeMap] `{ name => type }` pairs of types in this schema
     def types
@@ -221,6 +233,22 @@ module GraphQL
       end
     end
 
+    # Returns a list of Arguments and Fields referencing a certain type
+    # @param type_name [String]
+    # @return [Hash]
+    def references_to(type_name)
+      rebuild_artifacts unless defined?(@type_reference_map)
+      @type_reference_map.fetch(type_name, [])
+    end
+
+    # Returns a list of Union types in which a type is a member
+    # @param type [GraphQL::ObjectType]
+    # @return [Array<GraphQL::UnionType>] list of union types of which the type is a member
+    def union_memberships(type)
+      rebuild_artifacts unless defined?(@union_memberships)
+      @union_memberships.fetch(type.name, [])
+    end
+
     # Execute a query on itself. Raises an error if the schema definition is invalid.
     # @see {Query#initialize} for arguments.
     # @return [Hash] query result, ready to be serialized as JSON
@@ -544,7 +572,10 @@ module GraphQL
         @rebuilding_artifacts = true
         traversal = Traversal.new(self)
         @types = traversal.type_map
+        @root_types = [query, mutation, subscription]
         @instrumented_field_map = traversal.instrumented_field_map
+        @type_reference_map = traversal.type_reference_map
+        @union_memberships = traversal.union_memberships
       end
     ensure
       @rebuilding_artifacts = false

data/lib/graphql/schema/traversal.rb

@@ -10,6 +10,12 @@ module GraphQL
       # @return [Hash<String => Hash<String => GraphQL::Field>>]
       attr_reader :instrumented_field_map
 
+      # @return [Hash<String => Array<GraphQL::Field || GraphQL::Argument || GraphQL::Directive>]
+      attr_reader :type_reference_map
+
+      # @return [Hash<String => Array<GraphQL::BaseType>]
+      attr_reader :union_memberships
+
       # @param schema [GraphQL::Schema]
       def initialize(schema, introspection: true)
         @schema = schema
@@ -21,6 +27,8 @@ module GraphQL
 
         @type_map = {}
         @instrumented_field_map = Hash.new { |h, k| h[k] = {} }
+        @type_reference_map = Hash.new { |h, k| h[k] = [] }
+        @union_memberships = Hash.new { |h, k| h[k] = [] }
         visit(schema, nil)
       end
 
@@ -40,6 +48,7 @@ module GraphQL
           visit_roots.each { |t| visit(t, t.name) }
         when GraphQL::Directive
           member.arguments.each do |name, argument|
+            @type_reference_map[argument.type.unwrap.to_s] << argument
             visit(argument.type, "Directive argument #{member.name}.#{name}")
           end
         when GraphQL::BaseType
@@ -56,9 +65,13 @@ module GraphQL
             when GraphQL::InterfaceType
               visit_fields(type_defn)
             when GraphQL::UnionType
-              type_defn.possible_types.each { |t| visit(t, "Possible type for #{type_defn.name}") }
+              type_defn.possible_types.each do |t|
+                @union_memberships[t.name] << type_defn
+                visit(t, "Possible type for #{type_defn.name}")
+              end
             when GraphQL::InputObjectType
               type_defn.arguments.each do |name, arg|
+                @type_reference_map[arg.type.unwrap.to_s] << arg
                 visit(arg.type, "Input field #{type_defn.name}.#{name}")
               end
             end
@@ -78,8 +91,10 @@ module GraphQL
             inst.instrument(type_defn, defn)
           end
           @instrumented_field_map[type_defn.name][instrumented_field_defn.name] = instrumented_field_defn
+          @type_reference_map[instrumented_field_defn.type.unwrap.name] << instrumented_field_defn
           visit(instrumented_field_defn.type, "Field #{type_defn.name}.#{instrumented_field_defn.name}'s return type")
           instrumented_field_defn.arguments.each do |name, arg|
+            @type_reference_map[arg.type.unwrap.to_s] << arg
             visit(arg.type, "Argument #{name} on #{type_defn.name}.#{instrumented_field_defn.name}")
           end
         end

data/lib/graphql/schema/warden.rb

@@ -45,14 +45,14 @@ module GraphQL
 
       # @return [Array<GraphQL::BaseType>] Visible types in the schema
       def types
-        @types ||= @schema.types.each_value.select { |t| visible?(t) }
+        @types ||= @schema.types.each_value.select { |t| visible_type?(t) }
       end
 
       # @return [GraphQL::BaseType, nil] The type named `type_name`, if it exists (else `nil`)
       def get_type(type_name)
         @visible_types ||= read_through do |name|
           type_defn = @schema.types.fetch(name, nil)
-          if type_defn && visible?(type_defn)
+          if type_defn && visible_type?(type_defn)
             type_defn
           else
             nil
@@ -81,7 +81,7 @@ module GraphQL
 
       # @return [Array<GraphQL::BaseType>] The types which may be member of `type_defn`
       def possible_types(type_defn)
-        @visible_possible_types ||= read_through { |type_defn| @schema.possible_types(type_defn).select { |t| visible?(t) } }
+        @visible_possible_types ||= read_through { |type_defn| @schema.possible_types(type_defn).select { |t| visible_type?(t) } }
         @visible_possible_types[type_defn]
       end
 
@@ -126,8 +126,44 @@ module GraphQL
 
       private
 
+      def union_memberships(obj_type)
+        @unions ||= read_through { |obj_type| @schema.union_memberships(obj_type).select { |u| visible?(u) } }
+        @unions[obj_type]
+      end
+
       def visible_field?(field_defn)
-        visible?(field_defn) && visible?(field_defn.type.unwrap)
+        visible?(field_defn) && visible_type?(field_defn.type.unwrap)
+      end
+
+      def visible_type?(type_defn)
+        visible?(type_defn) && (
+            root_type?(type_defn) ||
+            type_defn.introspection? ||
+            referenced?(type_defn) ||
+            visible_abstract_type?(type_defn) ||
+            possible_types?(type_defn)
+          )
+      end
+
+      def root_type?(type_defn)
+        @schema.root_types.include?(type_defn)
+      end
+
+      def referenced?(type_defn)
+        members = @schema.references_to(type_defn.unwrap.name)
+        members.any? { |m| visible?(m) }
+      end
+
+      def visible_abstract_type?(type_defn)
+        type_defn.kind.object? && (
+            interfaces(type_defn).any? ||
+            union_memberships(type_defn).any?
+          )
+      end
+
+      def possible_types?(type_defn)
+        (type_defn.kind.union? || type_defn.kind.interface?) &&
+          @schema.possible_types(type_defn).any? { |t| visible_type?(t) }
       end
 
       def visible?(member)

data/lib/graphql/static_validation/validator.rb

@@ -22,29 +22,31 @@ module GraphQL
       # @param query [GraphQL::Query]
       # @return [Array<Hash>]
       def validate(query, validate: true)
-        context = GraphQL::StaticValidation::ValidationContext.new(query)
-        rewrite = GraphQL::InternalRepresentation::Rewrite.new
+        GraphQL::Tracing.trace("validate", { validate: validate, query: query }) do
+          context = GraphQL::StaticValidation::ValidationContext.new(query)
+          rewrite = GraphQL::InternalRepresentation::Rewrite.new
 
-        # Put this first so its enters and exits are always called
-        rewrite.validate(context)
+          # Put this first so its enters and exits are always called
+          rewrite.validate(context)
 
-        # If the caller opted out of validation, don't attach these
-        if validate
-          @rules.each do |rules|
-            rules.new.validate(context)
+          # If the caller opted out of validation, don't attach these
+          if validate
+            @rules.each do |rules|
+              rules.new.validate(context)
+            end
           end
-        end
 
-        context.visitor.visit
-        # Post-validation: allow validators to register handlers on rewritten query nodes
-        rewrite_result = rewrite.document
-        GraphQL::InternalRepresentation::Visit.visit_each_node(rewrite_result.operation_definitions, context.each_irep_node_handlers)
+          context.visitor.visit
+          # Post-validation: allow validators to register handlers on rewritten query nodes
+          rewrite_result = rewrite.document
+          GraphQL::InternalRepresentation::Visit.visit_each_node(rewrite_result.operation_definitions, context.each_irep_node_handlers)
 
-        {
-          errors: context.errors,
-          # If there were errors, the irep is garbage
-          irep: context.errors.any? ? nil : rewrite_result,
-        }
+          {
+            errors: context.errors,
+            # If there were errors, the irep is garbage
+            irep: context.errors.any? ? nil : rewrite_result,
+          }
+        end
       end
     end
   end

data/lib/graphql/subscriptions.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+require "graphql/subscriptions/event"
+require "graphql/subscriptions/instrumentation"
+if defined?(ActionCable)
+  require "graphql/subscriptions/action_cable_subscriptions"
+end
+
+module GraphQL
+  class Subscriptions
+    def self.use(defn, options = {})
+      schema = defn.target
+      options[:schema] = schema
+      schema.subscriptions = self.new(options)
+      instrumentation = Subscriptions::Instrumentation.new(schema: schema)
+      defn.instrument(:field, instrumentation)
+      defn.instrument(:query, instrumentation)
+      nil
+    end
+
+    def initialize(kwargs)
+      @schema = kwargs[:schema]
+    end
+
+    # Fetch subscriptions matching this field + arguments pair
+    # And pass them off to the queue.
+    # @param event_name [String]
+    # @param args [Hash]
+    # @param object [Object]
+    # @param scope [Symbol, String]
+    # @return [void]
+    def trigger(event_name, args, object, scope: nil)
+      field = @schema.get_field("Subscription", event_name)
+      if !field
+        raise "No subscription matching trigger: #{event_name}"
+      end
+
+      event = Subscriptions::Event.new(
+        name: event_name,
+        arguments: args,
+        field: field,
+        scope: scope,
+      )
+      execute_all(event, object)
+    end
+
+    def initialize(schema:, **rest)
+      @schema = schema
+    end
+
+    # `event` was triggered on `object`, and `subscription_id` was subscribed,
+    # so it should be updated.
+    #
+    # Load `subscription_id`'s GraphQL data, re-evaluate the query, and deliver the result.
+    #
+    # This is where a queue may be inserted to push updates in the background.
+    #
+    # @param subscription_id [String]
+    # @param event [GraphQL::Subscriptions::Event] The event which was triggered
+    # @param object [Object] The value for the subscription field
+    # @return [void]
+    def execute(subscription_id, event, object)
+      # Lookup the saved data for this subscription
+      query_data = read_subscription(subscription_id)
+      # Fetch the required keys from the saved data
+      query_string = query_data.fetch(:query_string)
+      variables = query_data.fetch(:variables)
+      context = query_data.fetch(:context)
+      operation_name = query_data.fetch(:operation_name)
+      # Re-evaluate the saved query
+      result = @schema.execute(
+        {
+          query: query_string,
+          context: context,
+          subscription_topic: event.topic,
+          operation_name: operation_name,
+          variables: variables,
+          root_value: object,
+        }
+      )
+      deliver(subscription_id, result)
+    end
+
+    # Event `event` occurred on `object`,
+    # Update all subscribers.
+    # @param event [Subscriptions::Event]
+    # @param object [Object]
+    # @return [void]
+    def execute_all(event, object)
+      each_subscription_id(event) do |subscription_id|
+        execute(subscription_id, event, object)
+      end
+    end
+
+    # Get each `subscription_id` subscribed to `event.topic` and yield them
+    # @param event [GraphQL::Subscriptions::Event]
+    # @yieldparam subscription_id [String]
+    # @return [void]
+    def each_subscription_id(event)
+      raise NotImplementedError
+    end
+
+    # The system wants to send an update to this subscription.
+    # Read its data and return it.
+    # @param subscription_id [String]
+    # @return [Hash] Containing required keys
+    def read_subscription(subscription_id)
+      raise NotImplementedError
+    end
+
+    # A subscription query was re-evaluated, returning `result`.
+    # The result should be send to `subscription_id`.
+    # @param subscription_id [String]
+    # @param result [Hash]
+    # @param context [GraphQL::Query::Context]
+    # @return [void]
+    def deliver(subscription_id, result, context)
+      raise NotImplementedError
+    end
+
+    # `query` was executed and found subscriptions to `events`.
+    # Update the database to reflect this new state.
+    # @param query [GraphQL::Query]
+    # @param events [Array<GraphQL::Subscriptions::Event>]
+    # @return [void]
+    def write_subscription(query, events)
+      raise NotImplementedError
+    end
+  end
+end