rails-graphql 0.1.0

data/lib/rails/graphql/request/component/operation.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # = GraphQL Request Component Operation
+      #
+      # This class holds information about a given operation. This will guide
+      # the validation and execution of it.
+      class Component::Operation < Component
+        extend ActiveSupport::Autoload
+
+        include SelectionSet
+        include Directives
+
+        class << self
+          alias type kind
+
+          # Helper method to initialize an operation given the data
+          def build(request, node, data)
+            request.build(const_get(data[:kind].classify), request, node, data)
+          end
+
+          # Rewrite the kind to always return +:operation+
+          def kind
+            :operation
+          end
+
+          # Defines if the current operation is a query type
+          def query?
+            false
+          end
+
+          # Defines if the current operation is a mutation type
+          def mutation?
+            false
+          end
+
+          # Defines if the current operation is a subscription type
+          def subscription?
+            false
+          end
+        end
+
+        # Query is default behavior, so it doesn't need a whole class
+        Query    = Class.new(self) { redefine_singleton_method(:query?)    { true } }
+        Mutation = Class.new(self) { redefine_singleton_method(:mutation?) { true } }
+
+        autoload :Subscription
+
+        delegate :type, :query?, :mutation?, :subscription?, to: :class
+
+        attr_reader :name, :variables, :arguments, :request
+
+        alias gql_name name
+        alias operation itself
+        alias vars variables
+        alias all_arguments arguments
+
+        def initialize(request, node, data)
+          @name = data[:name]
+          @request = request
+
+          super(node, data)
+
+          check_invalid_operation!
+        end
+
+        # The list of fields comes from the +fields_for+ of the same type as
+        # the +type+ of the operation
+        def fields_source
+          schema.fields_for(type)
+        end
+
+        # The typename is always based on the fake name used for the set of
+        # schema fields
+        def typename
+          schema.type_name_for(type)
+        end
+
+        # Support memory object to save information across the iteration
+        def memo
+          @memo ||= OpenStruct.new
+        end
+
+        # Add a empty entry if the operation has a name
+        def resolve_invalid
+          response.safe_add(name, nil) if stacked_selection?
+        end
+
+        # Stores all the used arguments to report not used ones
+        def used_variables
+          @used_variables ||= Set.new
+        end
+
+        # A fast way to access the correct display name for log or errors
+        def log_source
+          @log_source ||= name.blank? ? type : "#{name} #{type}"
+        end
+
+        protected
+
+          # Trigger an specific event with the +type+ of the operation
+          def organize
+            organize_then do
+              trigger_event(type)
+              yield if block_given?
+              organize_fields
+              report_unused_variables
+            end
+          end
+
+          # Perform the organization step
+          def organize_then(&block)
+            super(block) do
+              parse_variables
+              parse_directives(type)
+              parse_selection
+            end
+          end
+
+          # Resolve all the fields
+          def resolve
+            resolve_then { resolve_fields }
+          end
+
+          # Don't stack over response when the operation doesn't have a name
+          # TODO: As per spec, when an operation has variables, it should not
+          # be stacked
+          def stacked_selection?
+            name.present? && request.operations.size > 1
+          end
+
+          # Name used for debug purposes
+          def display_name
+            @display_name ||= "#{type.to_s.titlecase} #{name.presence || '__default__'}"
+          end
+
+          # Add an error for each not used variable and then clean up some data
+          def report_unused_variables
+            (arguments.keys - used_variables.to_a).each do |key|
+              argument = arguments[key]
+              request.report_node_error(<<~MSG.squish, argument.node || @node)
+                Unused variable $#{argument.gql_name} on #{log_source}.
+              MSG
+            end
+
+            @arguments = nil
+            @used_variables = nil
+          end
+
+          # If there is another operation with the same name already defined,
+          # raise an error. If an anonymous was started, then any other
+          # operatios is invalid.
+          def check_invalid_operation!
+            if request.operations.key?(nil)
+              invalidate!
+
+              request.report_node_error(<<~MSG.squish, @node)
+                Unable to process the operation #{display_name} when the document
+                contain multiple anonymous operations.
+              MSG
+            elsif request.operations.key?(name)
+              invalidate!
+
+              other_node = request.operations[name].instance_variable_get(:@node)
+              location = GraphQL::Native.get_location(other_node)
+
+              request.report_node_error(<<~MSG.squish, @node)
+                Duplicated operation named "#{name}" defined on
+                line #{location.begin_line}:#{location.begin_column}.
+              MSG
+            end
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/request/component/operation/subscription.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      class Component # :nodoc:
+        # = GraphQL Request Component Subscription Operation
+        #
+        # Handles a subscription operation inside a request.
+        class Operation::Subscription < Operation
+          redefine_singleton_method(:subscription?) { true }
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/request/component/spread.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # = GraphQL Request Component Spread
+      #
+      # This class holds information about a given spread that should be
+      # iterated, which connect to either a fragment or an inline selection
+      class Component::Spread < Component
+        include SelectionSet
+        include Directives
+
+        delegate :operation, :typename, to: :parent
+        delegate :variables, to: :operation
+
+        parent_memoize :request
+
+        attr_reader :name, :parent, :fragment, :type_klass
+
+        def initialize(parent, node, data)
+          @parent = parent
+
+          @name = data[:name]
+          @inline = data[:inline]
+
+          super(node, data)
+        end
+
+        # Check if the object is an inline spread
+        def inline?
+          @inline.present?
+        end
+
+        # Redirect to the fragment or check the inline type before resolving
+        def resolve_with!(object)
+          return if invalid?
+
+          @current_object = object
+          resolve!
+        ensure
+          @current_object = nil
+        end
+
+        protected
+
+          # Spread always resolve inline selection unstacked on response,
+          # meaning that its fields will be set in the same level as the parent
+          def stacked_selection?
+            false
+          end
+
+          # Just provide the correct location for directives
+          def parse_directives
+            super(inline? ? :inline_fragment : :fragment_spread)
+          end
+
+          # Scope the arguments whenever stacked within a spread
+          def stacked(*)
+            Request::Arguments.scoped(operation) { super }
+          end
+
+          # Normal mode of the organize step
+          # TODO: Once the fragment is organized, double checks the needed
+          # variables to ensure that the operation has everything necessary
+          def organize
+            inline? ? organize_then { organize_fields } : organize_then do
+              run_on_fragment(:organize!)
+              # Ensure necessary variables
+            end
+          end
+
+          # Perform the organization step
+          def organize_then(&block)
+            super(block) do
+              if inline?
+                @type_klass = find_type!(data[:type])
+                parse_selection
+              else
+                @fragment = request.fragments[name]
+                raise ArgumentError, <<~MSG.squish if @fragment.nil?
+                  The "#{name}" fragment is not defined in this request.
+                MSG
+              end
+
+              parse_directives
+            end
+          end
+
+          # Spread has a special behavior when using a fragment
+          def prepare
+            return super if inline?
+            raise 'Prepare with fragment not implemented yet'
+          end
+
+          # Resolve the spread operation
+          def resolve
+            return if invalid?
+
+            object = (defined?(@current_object) && @current_object) || parent.type_klass
+            return run_on_fragment(:resolve_with!, object) unless inline?
+
+            super if type_klass =~ object
+          end
+
+          # This will just trigger the selection resolver
+          def resolve_then(&block)
+            super(block) { resolve_fields(@current_object) }
+          end
+
+          # Most of the things that are redirected to the fragment needs to run
+          # inside a arguments scoped
+          def run_on_fragment(method_name, *args)
+            Request::Arguments.scoped(operation) { fragment.public_send(method_name, *args) }
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/request/component/typename.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # = GraphQL Request Component Typename
+      #
+      # Extra component which simulates a field that its only purpose is to
+      # return the name of the parent GraphQL object
+      class Component::Typename < Component
+        include ValueWriters
+        include Directives
+
+        delegate :operation, to: :parent
+        delegate :variables, to: :operation
+
+        parent_memoize :request
+
+        attr_reader :name, :alias_name, :parent
+
+        # Rewrite the kind to always return +:field+
+        def self.kind
+          :field
+        end
+
+        def initialize(parent, node, data)
+          @parent = parent
+
+          @name = data[:name]
+          @alias_name = data[:alias]
+
+          super(node, data)
+        end
+
+        # Set the value that the field will be resolved as
+        def resolve_with!(object)
+          @typename = object.gql_name
+          resolve!
+        ensure
+          @typename = nil
+        end
+
+        # Return the name of the field to be used on the response
+        def gql_name
+          alias_name || name
+        end
+
+        # Write the typename information
+        def write_value(value)
+          response.serialize(Type::Scalar::StringScalar, gql_name, value)
+        end
+
+        protected
+
+          # Normal mode of the organize step
+          def organize
+            organize_then
+          end
+
+          # Perform the organization step
+          def organize_then(&block)
+            super(block) { parse_directives(:field) }
+          end
+
+          # Go through the right flow to write the value
+          def resolve_then
+            super do
+              typename = @typename || parent.typename
+              raise InvalidValueError, <<~MSG.squish if typename.blank?
+                The #{gql_name} field value cannot be null.
+              MSG
+
+              strategy.resolve(self, typename) do |value|
+                yield value if block_given?
+                trigger_event(:finalize)
+              end
+            end
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/request/context.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # = GraphQL Request Context
+      #
+      # This class is used as context for the response while processing fields,
+      # objects, or any data that it's going to be placed on the response
+      class Context
+        attr_reader :current
+
+        def initialize
+          @stack = []
+          @current = Helpers::AttributeDelegator.new(self, :current_value, cache: false)
+        end
+
+        # Add, exec, and then remove the value from the stack
+        def stacked(value)
+          @stack.unshift(value) unless value.eql?(@stack[0])
+          yield(@current)
+        ensure
+          @stack.shift
+        end
+
+        # Find the parent object
+        def parent
+          @stack[1]
+        end
+
+        # Get all ancestors objects
+        def ancestors
+          @stack[1..-1]
+        end
+
+        # Get the current value, which basically means basically the first item
+        # on the current stafck
+        def current_value
+          @stack[0]
+        end
+
+        # Change the current value, either form hits or the actual value
+        def override_value(value)
+          @stack[0] = value
+        end
+
+        alias current_value= override_value
+      end
+    end
+  end
+end