rails-graphql 0.1.0

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # = GraphQL Request Arguments
+      #
+      # This is an extension of an +OpenStruct+ since argument values can be
+      # assigned a Proc, which means that in order to collect their value, we
+      # need to rely on the current operation being processed.
+      #
+      # They lazy variable-based value is used for fragments, so that they can
+      # be organized only once and have their variables changed accordingly to
+      # the spread and operation.
+      class Arguments < OpenStruct
+        THREAD_KEY = :_rails_graphql_operation
+        LAZY_LOADER = ->(key, object) { object.variables[key] }.curry
+
+        delegate :key?, to: :@table
+
+        class << self
+          # Easy access to the easy loader method
+          def lazy
+            LAZY_LOADER
+          end
+
+          # Get the current operation thread safely
+          def operation
+            Thread.current[THREAD_KEY]
+          end
+
+          # Execute a block inside a scoped thread-safe arguments
+          def scoped(value)
+            old_value, Thread.current[THREAD_KEY] = operation, value
+
+            yield
+          ensure
+            Thread.current[THREAD_KEY] = old_value
+          end
+
+          # Check if it's performing inside a scoped value
+          def scoped?
+            operation.present?
+          end
+
+          # If it's running under a scope, transform proc based values
+          def transform(value)
+            return if value.nil?
+            scoped? && value.is_a?(Proc) ? value.call(operation) : value
+          end
+        end
+
+        # Transform any proc by its actual value before returning the hash
+        def to_h(*)
+          super.transform_values(&self.class.method(:transform))
+        end
+
+        # Before iterating, transform any needed value
+        def each_pair
+          enum = to_h.to_enum
+          return enum unless block_given?
+          enum.each { |v| yield v }
+          self
+        end
+
+        # rubocop:disable Style/MissingRespondToMissing
+        # Transform the value before returning
+        def method_missing(*)
+          self.class.transform(super)
+        end
+        # rubocop:enable Style/MissingRespondToMissing
+
+        # Transform the value before returning
+        def [](*)
+          self.class.transform(super)
+        end
+
+        # Transform the value before returning
+        def dig(name, *names)
+          result = self.class.transform(super(name))
+          names.empty? ? result : result&.dig(*names)
+        end
+
+        # Override the freeze method to just freeze the table and do not create
+        # the getters and setter methods
+        def freeze
+          @table.freeze
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # = GraphQL Request Component
+      #
+      # Component is an abstraction of any possible type of object represented
+      # by a not of the document of a request. This class helps building
+      # cross-component features, like holding event listeners, setting up
+      # commom initializer and providing helpers
+      class Component
+        extend ActiveSupport::Autoload
+
+        include Request::Organizable
+        include Request::Prepareable
+        include Request::Resolveable
+
+        class << self
+          # Return the kind of the component
+          def kind
+            @kind ||= name.demodulize.underscore.to_sym
+          end
+
+          # Helper to memoize results from parent delegation
+          def parent_memoize(*methods)
+            methods.each do |method_name|
+              define_method(method_name) do
+                result = parent.public_send(method_name)
+                define_singleton_method(method_name) { result }
+                result
+              end
+            end
+          end
+        end
+
+        attr_reader :data
+
+        delegate :schema, :visitor, :response, :strategy, to: :request
+        delegate :find_type!, :find_directive!, :trigger_event, to: :strategy
+        delegate :memo, to: :operation
+        delegate :kind, to: :class
+
+        alias of_type? is_a?
+
+        eager_autoload do
+          autoload :Field
+          autoload :Fragment
+          autoload :Operation
+          autoload :Spread
+          autoload :Typename
+        end
+
+        def initialize(node, data)
+          @node = node
+          @data = data
+        end
+
+        # Check if the component is in a invalid state
+        def invalid?
+          defined?(@invalid) && @invalid
+        end
+
+        # Mark the component as invalid
+        def invalidate!
+          @invalid = true
+        end
+
+        # Normaly, components are not assignable, only fields are
+        def assignable?
+          false
+        end
+
+        protected
+
+          # It's extremely important to have a way to access the current request
+          # since not all objects stores s direct pointer to it
+          def request
+            raise NotImplementedError
+          end
+
+          # Use the strategy to set the component into the stack
+          def stacked(value = self, &block)
+            strategy.stacked(value, &block)
+          end
+
+          # Run a given block and ensure to capture exceptions to set them as
+          # errors
+          def capture_exception(stage, invalidate = false)
+            yield
+          rescue StandardError => error
+            invalidate! if invalidate
+            stack_path = request.stack_to_path
+            stack_path << gql_name if respond_to?(:gql_name) && gql_name.present?
+            request.exception_to_error(error, @node, path: stack_path, stage: stage.to_s)
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # = GraphQL Request Component Field
+      #
+      # This class holds information about a given field that should be
+      # collected from the source of where it was requested.
+      class Component::Field < Component
+        include ValueWriters
+        include SelectionSet
+        include Directives
+
+        delegate :decorate, to: :type_klass
+        delegate :operation, :variables, to: :parent
+        delegate :method_name, :resolver, :performer, :type_klass, :leaf_type?,
+          :dynamic_resolver?, to: :field
+
+        parent_memoize :request
+
+        attr_reader :name, :alias_name, :parent, :field, :arguments, :current_object
+
+        alias args arguments
+
+        def initialize(parent, node, data)
+          @parent = parent
+
+          @name = data[:name]
+          @alias_name = data[:alias]
+
+          super(node, data)
+        end
+
+        # Return both the field directives and the request directives
+        def all_directives
+          field.all_directives + super
+        end
+
+        # Override that considers the requested field directives and also the
+        # definition field events, both from itself and its directives events
+        def all_listeners
+          field.all_listeners + super
+        end
+
+        # Override that considers the requested field directives and also the
+        # definition field events, both from itself and its directives events
+        def all_events
+          @all_events ||= Helpers.merge_hash_array(field.all_events, super)
+        end
+
+        # Get and cache all the arguments for the field
+        def all_arguments
+          request.cache(:arguments)[field] ||= begin
+            if (result = field.all_arguments).any?
+              result.each_value.map(&:gql_name).zip(result.each_value).to_h
+            else
+              {}
+            end
+          end
+        end
+
+        # Assign a given +field+ to this class. The field must be an output
+        # field, which means that +output_type?+ must be true. It also must be
+        # called exactly once per field.
+        def assing_to(field)
+          raise ArgumentError, <<~MSG.squish if defined?(@assigned)
+            The "#{gql_name}" field is already assigned to #{@field.inspect}.
+          MSG
+
+          @field = field
+        end
+
+        # Return the name of the field to be used on the response
+        def gql_name
+          alias_name || name
+        end
+
+        # A little helper for finding the correct parent type name
+        def typename
+          (try(:current_object) || try(:type_klass))&.gql_name
+        end
+
+        # Check if the field is an entry point, meaning that its parent is the
+        # operation and it is associated to a schema field
+        def entry_point?
+          parent.kind === :operation
+        end
+
+        # Fields are assignable because they are actually the selection, so they
+        # need to be assigned to a filed
+        def assignable?
+          true
+        end
+
+        # A little extension of the +is_a?+ method that allows checking it using
+        # the underlying +field+
+        def of_type?(klass)
+          super || field.of_type?(klass)
+        end
+
+        # When the field is invalid, there's no much to do
+        # TODO: Maybe add a invalid event trigger here
+        def resolve_invalid(error = nil)
+          request.exception_to_error(error, @node) if error.present?
+
+          validate_output!(nil)
+          response.safe_add(gql_name, nil)
+        rescue InvalidValueError
+          raise unless entry_point?
+        end
+
+        # When the +type_klass+ of an object is an interface or a union, the
+        # field needs to be redirected to the one from the actual resolved
+        # +object+ type
+        def resolve_with!(object)
+          return resolve! if invalid?
+
+          old_field, @field = @field, object[@field.name]
+          @current_object = object
+          resolve!
+        ensure
+          @field, @current_object = old_field, nil
+        end
+
+        protected
+
+          # Perform the organization step
+          def organize_then(&block)
+            super(block) do
+              check_assignment!
+
+              parse_arguments
+              parse_directives
+              parse_selection
+            end
+          end
+
+          # Perform the prepare step
+          def prepare_then(&block)
+            super { strategy.prepare(self, &block) }
+          end
+
+          # Perform the resolve step
+          def resolve_then(&block)
+            stacked do
+              strategy.perform(self) if field.mutation?
+              send(field.array? ? 'resolve_many' : 'resolve_one', &block)
+            rescue StandardError => error
+              resolve_invalid(error)
+            end
+          end
+
+          # Don't stack over response when it's processing as array
+          def stacked_selection?
+            !field.array?
+          end
+
+        private
+
+          # Resolve the value of the field for a single information
+          def resolve_one
+            strategy.resolve(self, decorate: true) do |value|
+              yield value if block_given?
+              trigger_event(:finalize)
+            end
+          end
+
+          # Resolve the field for a list of information
+          def resolve_many
+            strategy.resolve(self, array: true) do |item|
+              strategy.resolve(self, item, decorate: true) do |value|
+                yield value if block_given?
+                trigger_event(:finalize)
+              end
+            end
+          end
+
+          # This override allows reasigned fields to perform events. This
+          # happens when fields are originally organized from interfaces. If
+          # the event is stopped for the object, then it doesn't proceed to the
+          # strategy implementation, ensuring compatibility
+          def trigger_event(event_name, **xargs)
+            return super if !defined?(@current_object) || @current_object.nil?
+
+            listeners = request.cache(:dynamic_listeners)[field] ||= field.all_listeners
+            return super unless listeners.include?(event_name)
+
+            callbacks = request.cache(:dynamic_events)[field] ||= field.all_events
+            old_events, @all_events = @all_events, callbacks
+            super
+          ensure
+            @all_events = old_events
+          end
+
+          # Check if the field was assigned correctly to an output field
+          def check_assignment!
+            raise MissingFieldError, <<~MSG.squish if field.nil?
+              Unable to find a field named "#{gql_name}" on
+              #{entry_point? ? operation.kind : parent.type_klass.name}.
+            MSG
+
+            raise FieldError, <<~MSG.squish unless field.output_type?
+              The "#{gql_name}" was assigned to a non-output type of field: #{field.inspect}.
+            MSG
+
+            empty_selection = data[:selection].nil? || data[:selection].null?
+            raise FieldError, <<~MSG.squish if field.leaf_type? && !empty_selection
+              The "#{gql_name}" was assigned to the #{type_klass.gql_name} which
+              is a leaf type and does not have nested fields.
+            MSG
+
+            raise FieldError, <<~MSG.squish if !field.leaf_type? && empty_selection
+              The "#{gql_name}" was assigned to the #{type_klass.gql_name} which
+              is not a leaf type and requires a selection of fields.
+            MSG
+
+            raise DisabledFieldError, <<~MSG.squish if field.disabled?
+              The "#{gql_name}" was found but it is marked as disabled.
+            MSG
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # = GraphQL Request Component Fragment
+      #
+      # This class holds information about a given fragment defined using the
+      # +fragment+ statement during an execution. This will guide the validation
+      # and execution of it.
+      class Component::Fragment < Component
+        include SelectionSet
+        include Directives
+
+        attr_reader :name, :type_klass, :request
+
+        def initialize(request, node, data)
+          @name = data[:name]
+          @request = request
+
+          super(node, data)
+
+          check_duplicated_fragment!
+        end
+
+        # Return a lazy loaded variable proc
+        # TODO: Mark all the dependent variables
+        def variables
+          Request::Arguments.lazy
+        end
+
+        # Access the operation through the Request::Arguments
+        def operation
+          Request::Arguments.operation
+        end
+
+        # Spread should always be performed with a current object, thus the
+        # typename comes from it
+        def typename
+          @current_object.gql_name
+        end
+
+        # Only resolve if the +type_klass+ is equivalent to the given +object+
+        def resolve_with!(object)
+          return if invalid?
+
+          @current_object = object
+          resolve!
+        ensure
+          @current_object = nil
+        end
+
+        protected
+
+          # Fragments always resolve selection unstacked on response, meaning
+          # that its fields will be set in the same level as the parent
+          def stacked_selection?
+            false
+          end
+
+          # Perform the organization step
+          def organize_then(&block)
+            super(block) do
+              @type_klass = find_type!(data[:type])
+              parse_directives(:fragment_definition)
+
+              check_assignment!
+              parse_selection
+            end
+          end
+
+          # Resolve the spread operation
+          def resolve
+            return if invalid?
+
+            object = @current_object || type_klass
+            resolve_then if type_klass =~ object
+          end
+
+          # This will just trigger the selection resolver
+          def resolve_then(&block)
+            super(block) { resolve_fields(@current_object) }
+          end
+
+        private
+
+          # Check if the field was assigned correctly to an output field
+          def check_assignment!
+            raise ExecutionError, <<~MSG.squish unless type_klass.output_type?
+              Unable to assing #{type_klass.gql_name} to "#{name}" fragment because
+              it is not a output type.
+            MSG
+
+            raise ExecutionError, <<~MSG.squish if type_klass.leaf_type?
+              Unable to assing #{type_klass.gql_name} to "#{name}" fragment because
+              a "#{type_klass.kind}" type can not be the source of a fragmnet.
+            MSG
+          end
+
+          # If there is another fragment with the same name already defined,
+          # raise an error
+          def check_duplicated_fragment!
+            return unless request.fragments.key?(name)
+
+            invalidate!
+
+            other_node = request.fragments[name].instance_variable_get(:@node)
+            location = GraphQL::Native.get_location(other_node)
+
+            request.report_node_error(<<~MSG.squish, @node)
+              Duplicated fragment named "#{name}" defined on
+              line #{location.begin_line}:#{location.begin_column}
+            MSG
+          end
+      end
+    end
+  end
+end