rails-graphql 0.1.0

data/lib/rails/graphql/field/output_field.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # = GraphQL Output Field
+    #
+    # Most of the fields in a GraphQL operation are output fields or similar or
+    # proxies of it. They can express both leaf and branch data. They can also
+    # be the entry point of a GraphQL request.
+    class Field::OutputField < Field
+      include Helpers::WithArguments
+      include Helpers::WithValidator
+      include Field::ResolvedField
+      include Field::TypedField
+
+      module Proxied # :nodoc: all
+        def initialize(*args, **xargs, &block)
+          @method_name = xargs.delete(:method_name) if xargs.key?(:method_name)
+          super(*args, **xargs, &block)
+        end
+
+        def all_arguments
+          field.arguments.merge(super)
+        end
+
+        def has_argument?(name)
+          super || field.has_argument?(name)
+        end
+      end
+
+      redefine_singleton_method(:output_type?) { true }
+      self.directive_location = :field_definition
+
+      def initialize(*args, method_name: nil, deprecated: false, **xargs, &block)
+        @method_name = method_name.to_s.underscore.to_sym unless method_name.nil?
+
+        if deprecated.present?
+          xargs[:directives] = Array.wrap(xargs[:directives])
+          xargs[:directives] << Directive::DeprecatedDirective.new(
+            reason: (deprecated.is_a?(String) ? deprecated : nil),
+          )
+        end
+
+        super(*args, **xargs, &block)
+      end
+
+      # Check if the arguments are also equivalent
+      def =~(other)
+        super && match_arguments?(other)
+      end
+
+      # Checks if a given unserialized value is valid for this field
+      def valid_output?(value, deep: true)
+        return false unless super
+        return null? if value.nil?
+        return valid_output_array?(value, deep) if array?
+
+        return true unless leaf_type? || deep
+        type_klass.valid_output?(value)
+      end
+
+      # Trigger the exception based value validator
+      def validate_output!(value, **xargs)
+        super(value, :field, **xargs)
+      rescue ValidationError => error
+        raise InvalidValueError, error.message
+      end
+
+      # Checks if the default value of the field is valid
+      def validate!(*)
+        super if defined? super
+
+        raise ArgumentError, <<~MSG.squish unless type_klass.output_type?
+          The "#{type_klass.gql_name}" is not a valid output type.
+        MSG
+      end
+
+      protected
+
+        # Check if the given +value+ is a valid array as output
+        def valid_output_array?(value, deep)
+          return false unless value.is_a?(Enumerable)
+
+          value.all? do |val|
+            (val.nil? && nullable?) || (leaf_type? || !deep) ||
+              type_klass.valid_output?(val)
+          end
+        end
+
+        def proxied # :nodoc:
+          super if defined? super
+          extend Field::OutputField::Proxied
+        end
+    end
+  end
+end

data/lib/rails/graphql/field/proxied_field.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # = GraphQL Proxied Field
+    #
+    # Proxied fields are a soft way to copy a real field. The good part is that
+    # if the field changes for any reason all its copies will change as well.
+    #
+    # The owner of a proxy field is different from the owner of the actual field
+    # but that doesn't affect the field operations.
+    #
+    # Proxied field also supports aliases, which helps implementing independent
+    # fields and then providing them as proxy to other objects.
+    #
+    # Proxies can be created from any kind of input
+    #
+    # ==== Options
+    #
+    # It accepts all the options of any other type of field plus the following
+    #
+    # * <tt>:owner</tt> - The main object that this field belongs to.
+    # * <tt>:as</tt> - The actual name to be used on the field while assigning
+    #   the proxy (defaults to nil).
+    # * <tt>:alias</tt> - Same as the +:as+ key (defaults to nil).
+    module Field::ProxiedField
+      delegate_missing_to :field
+      delegate :leaf_type?, :array?, :internal?, :valid_input?, :valid_output?,
+        :to_json, :as_json, :deserialize, :valid?, to: :field
+
+      Field.proxyable_methods %w[name gql_name method_name resolver description
+        null? nullable? enabled?], klass: self
+
+      def initialize(field, owner:, **xargs, &block)
+        @field = field
+        @owner = owner
+
+        apply_changes(**xargs, &block)
+      end
+
+      # Once this module is added then the field becomes a proxy
+      def proxy?
+        true
+      end
+
+      # Allow chaging most of the general kind-independent initialize settings
+      def apply_changes(**xargs, &block)
+        if (deprecated = xargs[:deprecated])
+          xargs[:directives] = Array.wrap(xargs[:directives])
+          xargs[:directives] << Directive::DeprecatedDirective.new(
+            reason: (deprecated.is_a?(String) ? deprecated : nil),
+          )
+        end
+
+        @directives = GraphQL.directives_to_set(xargs[:directives], source: self) \
+          if xargs.key?(:directives)
+
+        @desc    = xargs[:desc]&.strip_heredoc&.chomp if xargs.key?(:desc)
+        @enabled = xargs.fetch(:enabled, !xargs.fetch(:disabled, false)) \
+          if xargs.key?(:enabled) || xargs.key?(:disabled)
+
+        normalize_name(xargs.fetch(:alias, xargs[:as]))
+        super
+      end
+
+      # Return the original owner from +field+
+      def proxied_owner
+        field.owner
+      end
+
+      # Return the proxied field
+      def proxied_field
+        @field
+      end
+
+      def disable! # :nodoc:
+        super unless non_interface_proxy!('disable')
+      end
+
+      def enable! # :nodoc:
+        super unless non_interface_proxy!('enable')
+      end
+
+      def all_directives # :nodoc:
+        field.all_directives + super
+      end
+
+      # It is important to ensure that the proxied field is also valid. If the
+      # proxied owner is registered, then it is safe to assume that it is valid
+      def validate!(*)
+        super if defined? super
+        field.validate! unless GraphQL.type_map.object_exist?(
+          proxied_owner,
+          namespaces: namespaces,
+          exclusive: true,
+        )
+      end
+
+      protected
+
+        alias field proxied_field
+
+        def normalize_name(value) # :nodoc:
+          super unless value.blank? || non_interface_proxy!('rename')
+        end
+
+        # Prohibits changes to proxy fields based on interfaces
+        def non_interface_proxy!(action)
+          raise ::ArgymentError, <<~MSG.squish if interface_proxy?
+            Unable to #{action} the "#{gql_name}" field because it is
+            associated to the #{field.owner.name} interface.
+          MSG
+        end
+
+        # Checks if the proxy is based on an interface field
+        def interface_proxy?
+          field.owner.try(:interface?)
+        end
+
+        # Display the source of the proxy for inspection
+        def inspect_source
+          "@source=#{proxied_owner.name}[:#{field.name}] [proxied]"
+        end
+
+        # This is trigerred when the field is proxied
+        def proxied
+          super if defined? super
+        end
+    end
+  end
+end

data/lib/rails/graphql/field/resolved_field.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # This provides ways for fields to be resolved manually, by adding callbacks
+    # and additional configurations in order to resolve a field value during a
+    # request
+    module Field::ResolvedField
+      module Proxied # :nodoc: all
+        def all_listeners
+          field.all_listeners + super
+        end
+
+        def all_events
+          events = defined?(@events) ? @events : {}
+          Helpers.merge_hash_array(field.all_events, events).transform_values do |arr|
+            arr.sort_by { |cb| cb.try(:target).is_a?(GraphQL::Field) ? 0 : 1 }
+          end
+        end
+
+        def resolver
+          super || field.resolver
+        end
+
+        def dynamic_resolver?
+          super || field.dynamic_resolver?
+        end
+      end
+
+      # Just add the callbacks setup to the field
+      def self.included(other)
+        other.include(Helpers::WithEvents)
+        other.include(Helpers::WithCallbacks)
+        other.event_types(:prepare, :finalize, expose: true)
+        other.alias_method(:before_resolve, :prepare)
+        other.alias_method(:after_resolve, :finalize)
+      end
+
+      # Add a block that is performed while resolving a value of a field
+      def resolve(*args, **xargs, &block)
+        @resolver = Callback.new(self, :resolve, *args, **xargs, &block)
+      end
+
+      # Get the resolver that can be already defined or used through the
+      # +method_name+
+      def resolver
+        return unless dynamic_resolver?
+        @resolver ||= Callback.new(self, :resolve, method_name)
+      end
+
+      # Check if the field has a dynamic resolver
+      def dynamic_resolver?
+        if defined?(@dynamic_resolver)
+          @dynamic_resolver
+        elsif defined?(@resolver)
+          @resolver.present?
+        else
+          callable?(method_name)
+        end
+      end
+
+      # Checks if all the named callbacks can actually be called
+      def validate!(*)
+        super if defined? super
+
+        # Store this result for performance purposes
+        @dynamic_resolver = dynamic_resolver?
+        return unless defined? @events
+
+        invalid = @events.each_value.reject do |callback|
+          callback.block.is_a?(Proc) || callable?(callback.block)
+        end
+
+        raise ArgumentError, <<~MSG.squish if invalid.present?
+          The "#{owner.name}" class does not define the following methods needed
+          for performing hooks: #{invalid.map(&:block).to_sentence}.
+        MSG
+      end
+
+      protected
+
+        # Chedck if a given +method_name+ is callable from the owner perspective
+        def callable?(method_name)
+          owner.is_a?(Class) && owner.try(:gql_resolver?, method_name)
+        end
+
+        def proxied # :nodoc:
+          super if defined? super
+          extend Field::ResolvedField::Proxied
+        end
+    end
+
+    Field::ScopedConfig.delegate :before_resolve, :after_resolve,
+      :prepare, :finalize, :resolve, to: :field
+  end
+end

data/lib/rails/graphql/field/scoped_config.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # Helper class to be used while configuring a field using a block. An
+    # instance of this class works as proxy for changes to the actual field.
+    Field::ScopedConfig = Struct.new(:field, :receiver) do
+      delegate :argument, :ref_argument, :id_argument, :use, :internal?, :disabled?,
+        :enabled?, :disable!, :enable!, to: :field
+
+      delegate_missing_to :receiver
+
+      def method_name(value)
+        field.instance_variable_set(:@method_name, value.to_sym)
+      end
+
+      def desc(value)
+        field.instance_variable_set(:@desc, value.strip_heredoc.chomp)
+      end
+    end
+  end
+end

data/lib/rails/graphql/field/typed_field.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # This is a helper module that basically works with fields that have an
+    # assigned type value
+    module Field::TypedField
+      module Proxied # :nodoc: all
+        delegate :type, to: :field
+      end
+
+      attr_reader :type
+
+      delegate :input_type?, :output_type?, :leaf_type?, :kind, to: :type_klass
+
+      def initialize(name, type, *args, **xargs, &block)
+        if type.is_a?(Module) && type < GraphQL::Type
+          @type_klass = type
+          @type = type.to_sym
+        else
+          @type = type.to_s.underscore.to_sym
+        end
+
+        super(name, *args, **xargs, &block)
+      end
+
+      def initialize_copy(*)
+        super
+
+        @type_klass = nil
+      end
+
+      # Check if types are compatible
+      def =~(other)
+        other.is_a?(Field::TypedField) && other.type_klass =~ type_klass && super
+      end
+
+      # Sometimes the owner does not designate this, but it is safe to assume it
+      # will be associated to the object valyd types
+      def valid_field_types
+        owner.try(:valid_field_types) || Type::Object.valid_field_types
+      end
+
+      # A little extension of the +is_a?+ method that allows checking it using
+      # the +type_klass+
+      def of_type?(klass)
+        is_a?(klass) || type_klass <= klass
+      end
+
+      # Return the class of the type object
+      def type_klass
+        @type_klass ||= GraphQL.type_map.fetch!(type,
+          prevent_register: owner,
+          namespaces: namespaces,
+        )
+      end
+
+      # Add the listeners from the associated type
+      def all_listeners
+        type_klass.all_listeners + super
+      end
+
+      # Add the events from the associated type
+      def all_events
+        Helpers.merge_hash_array(type_klass.all_events, super)
+      end
+
+      # Checks if the type of the field is valid
+      def validate!(*)
+        super if defined? super
+
+        raise ArgumentError, <<~MSG.squish unless type_klass.is_a?(Module)
+          Unable to find the "#{type.inspect}" input type on GraphQL context.
+        MSG
+
+        valid_type = valid_field_types.empty? || valid_field_types.any? do |base_type|
+          type_klass < base_type
+        end
+
+        raise ArgumentError, <<~MSG.squish unless valid_type
+          The "#{type_klass.base_type}" is not accepted in this context.
+        MSG
+      end
+
+      protected
+
+        # Little helper that shows the type of the field
+        def inspect_type
+          result = ': '
+          result += '[' if array?
+          result += type_klass.gql_name
+          result += '!' if array? && !nullable?
+          result += ']' if array?
+          result += '!' unless null?
+          result
+        end
+
+        def proxied # :nodoc:
+          super if defined? super
+          extend Field::TypedField::Proxied
+        end
+    end
+  end
+end