rails-graphql 0.1.0

data/lib/rails/graphql/field.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # = GraphQL Field
+    #
+    # A field has multiple purposes, which is defined by the specific subclass
+    # used. They are also, in various ways, similar to arguments, since they
+    # tend to have the same structure.
+    # array as input.
+    #
+    # ==== Options
+    #
+    # * <tt>:owner</tt> - The main object that this field belongs to.
+    # * <tt>:null</tt> - Marks if the overall type can be null
+    #   (defaults to true).
+    # * <tt>:array</tt> - Marks if the type should be wrapped as an array
+    #   (defaults to false).
+    # * <tt>:nullable</tt> - Marks if the internal values of an array can be null
+    #   (defaults to true).
+    # * <tt>:full</tt> - Shortcut for +null: false, nullable: false, array: true+
+    #   (defaults to false).
+    # * <tt>:method_name</tt> - The name of the method used to fetch the field data
+    #   (defaults to nil).
+    # * <tt>:enabled</tt> - Mark the field as enabled
+    #   (defaults to true).
+    # * <tt>:disabled</tt> - Works as the oposite of the enabled option
+    #   (defaults to false).
+    # * <tt>:directives</tt> - The list of directives associated with the value
+    #   (defaults to nil).
+    # * <tt>:desc</tt> - The description of the argument
+    #   (defaults to nil).
+    #
+    # It also accepts a block for further configurations
+    class Field
+      extend ActiveSupport::Autoload
+      include Helpers::WithDirectives
+
+      autoload :ScopedConfig
+
+      autoload :ResolvedField
+      autoload :TypedField
+      autoload :ProxiedField
+
+      autoload :InputField
+      autoload :OutputField
+      autoload :MutationField
+
+      delegate :input_type?, :output_type?, :leaf_type?, :proxy?, :mutation?, to: :class
+
+      delegate :namespaces, to: :owner
+
+      attr_reader :name, :gql_name, :owner
+
+      class << self
+        # A small shared helper method that allows field information to be
+        # proxied
+        def proxyable_methods(*list, klass:, allow_nil: false)
+          list = list.flatten.compact.map do |method_name|
+            ivar = '@' + method_name.delete_suffix('?')
+            accessor = 'field' + (allow_nil ? '&.' : '.') + method_name
+            "def #{method_name}; defined?(#{ivar}) ? #{ivar} : #{accessor}; end"
+          end
+
+          klass.class_eval(list.join("\n"), __FILE__, __LINE__ + 1)
+        end
+
+        # Defines if the current field is valid as an input type
+        def input_type?
+          false
+        end
+
+        # Defines if the current field is valid as an output type
+        def output_type?
+          false
+        end
+
+        # Defines if the current field is considered a leaf output
+        def leaf_type?
+          false
+        end
+
+        # Checks if the the field is a proxy kind of field
+        def proxy?
+          false
+        end
+
+        # Checks if the field is associated with a mutation
+        def mutation?
+          false
+        end
+      end
+
+      def initialize(name, owner:, **xargs, &block)
+        @owner = owner
+        normalize_name(name)
+
+        @directives = GraphQL.directives_to_set(xargs[:directives], source: self)
+        @method_name = xargs[:method_name].to_s.underscore.to_sym \
+          unless xargs[:method_name].nil?
+
+        full      = xargs.fetch(:full, false)
+        @null     = full ? false : xargs.fetch(:null, true)
+        @array    = full ? true  : xargs.fetch(:array, false)
+        @nullable = full ? false : xargs.fetch(:nullable, true)
+
+        @desc = xargs[:desc]&.strip_heredoc&.chomp
+        @enabled = xargs.fetch(:enabled, !xargs.fetch(:disabled, false))
+
+        configure(&block) if block.present?
+      end
+
+      def initialize_copy(*) # :nodoc:
+        super
+
+        @owner = nil
+      end
+
+      # Apply a controlled set of changes to the field
+      def apply_changes(**xargs, &block)
+        required_items! unless xargs.fetch(:nullable, true)
+        required! unless xargs.fetch(:null, true)
+        disable! if xargs.fetch(:disabled, false)
+        enable! if xargs.fetch(:enabled, false)
+
+        @desc = xargs[:desc].strip_heredoc.chomp if xargs.key?(:desc)
+        configure(&block) if block.present?
+      end
+
+      # Allow extra configurations to be performed using a block
+      def configure(&block)
+        Field::ScopedConfig.new(self, block.binding.receiver).instance_exec(&block)
+      end
+
+      # Returns the name of the method used to retrieve the information
+      def method_name
+        defined?(@method_name) ? @method_name : @name
+      end
+
+      # Check if the other field is equivalent
+      def =~(other)
+        other.is_a?(GraphQL::Field) &&
+          other.array? == array? &&
+          (other.null? == null? || other.null? && !null?) &&
+          (other.nullable? == nullable? || other.nullable? && !nullable?)
+      end
+
+      # Checks if the argument can be null
+      def null?
+        !!@null
+      end
+
+      # Checks if the argument can be an array
+      def array?
+        !!@array
+      end
+
+      # Checks if the argument can have null elements in the array
+      def nullable?
+        !!@nullable
+      end
+
+      # Check if tre field is enabled
+      def enabled?
+        !!@enabled
+      end
+
+      # Check if tre field is disabled
+      def disabled?
+        !enabled?
+      end
+
+      # Mark the field as globally enabled
+      def enable!
+        @enabled = true
+      end
+
+      # Mark the field as globally disabled
+      def disable!
+        @enabled = false
+      end
+
+      # Return the description of the argument
+      def description
+        @desc
+      end
+
+      # Checks if a description was provided
+      def description?
+        defined?(@desc) && !!@desc
+      end
+
+      # Check if the field is an internal one
+      def internal?
+        name.start_with?('__')
+      end
+
+      # This method must be overridden by children classes
+      def valid_input?(*)
+        enabled?
+      end
+
+      # This method must be overridden by children classes
+      def valid_output?(*)
+        enabled?
+      end
+
+      # Transforms the given value to its representation in a JSON string
+      def to_json(value)
+        return 'null' if value.nil?
+        return type_klass.to_json(value) unless array?
+        value.map { |part| type_klass.to_json(part) }
+      end
+
+      # Turn the given value into a JSON string representation
+      def as_json(value)
+        return if value.nil?
+        return type_klass.as_json(value) unless array?
+        value.map { |part| type_klass.as_json(part) }
+      end
+
+      # Turn a user input of this given type into an ruby object
+      def deserialize(value)
+        return if value.nil?
+        return type_klass.deserialize(value) unless array?
+        value.map { |val| type_klass.deserialize(val) unless val.nil? }
+      end
+
+      # Check if the given value is valid using +valid_input?+ or
+      # +valid_output?+ depending of the type of the field
+      def valid?(value)
+        input_type? ? valid_input?(value) : valid_output?(value)
+      end
+
+      # Checks if the definition of the field is valid.
+      def validate!(*)
+        super if defined? super
+
+        raise NameError, <<~MSG.squish if gql_name.start_with?('__') && !internal?
+          The name "#{gql_name}" is invalid. Only internal fields from the
+          spec can have a name starting with "__".
+        MSG
+      end
+
+      # Update the null value
+      def required!
+        @null = false
+      end
+
+      # Update the nullable value
+      def required_items!
+        @nullable = false
+      end
+
+      # Create a proxy of the current field
+      def to_proxy(*args, **xargs, &block)
+        proxy = self.class.allocate
+        proxy.extend Field::ProxiedField
+        proxy.send(:proxied)
+        proxy.send(:initialize, self, *args, **xargs, &block)
+        proxy
+      end
+
+      def inspect # :nodoc:
+        <<~INSPECT.squish + '>'
+          #<#{self.class.name}
+          #{inspect_owner}
+          #{inspect_source}
+          #{inspect_enabled}
+          #{gql_name}#{inspect_arguments}#{inspect_type}
+          #{inspect_default_value}
+          #{inspect_directives}
+        INSPECT
+      end
+
+      protected
+
+        # Allow the subclasses to define the extra inspection methods
+        def respond_to_missing?(method_name, *)
+          method_name.start_with?('inspect_') || super
+        end
+
+        # Allow the subclasses to define the extra inspection methods
+        def method_missing(method_name, *)
+          method_name.start_with?('inspect_') ? '' : super
+        end
+
+        # Ensures the consistency of the name of the field
+        def normalize_name(value)
+          return if value.blank?
+
+          @name = value.to_s.underscore.to_sym
+          @gql_name = @name.to_s.gsub(/^_+/, '').camelize(:lower)
+
+          if internal?
+            @gql_name.prepend('__')
+          elsif @name.start_with?('_')
+            @gql_name.prepend('_')
+          end
+        end
+
+        # Helper method to inspect the directives
+        def inspect_directives
+          all_directives.map(&:inspect)
+        end
+
+        # Show the name of the owner of the object for inspection
+        def inspect_owner
+          owner.is_a?(Module) ? owner.name : owner.class.name
+        end
+
+        # Add a disable tag to the inspection if the field is disabled
+        def inspect_enabled
+          '[disabled]' if disabled?
+        end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # = GraphQL Input Field
+    #
+    # An input field works the same way as an argument and they are pretty much
+    # equivalent. The main difference between an argument and a input field is
+    # that input fields holds object-like values and they can be inherited.
+    # Arguments can hold object-like values only when their type is associated
+    # with an InputField.
+    #
+    # ==== Options
+    #
+    # * <tt>:default</tt> - Sets a default value for the argument (defaults to nil).
+    # * <tt>:directives</tt> - The list of directives associated with the value
+    #   (defaults to nil).
+    class Field::InputField < Field
+      include Field::TypedField
+
+      attr_reader :default
+
+      redefine_singleton_method(:input_type?) { true }
+      self.directive_location = :input_field_definition
+
+      def initialize(*args, default: nil, **xargs, &block)
+        super(*args, **xargs, &block)
+        @default = default
+      end
+
+      def configure # :nodoc:
+        raise ArgumentError, 'Input fields can\'t be further configured using blocks'
+      end
+
+      # Allow change the default value for the input
+      def apply_changes(**xargs, &block)
+        @default = xargs[:default] if xargs.key?(:default)
+        super
+      end
+
+      # Checks if a default value was provided
+      def default_value?
+        !default.nil?
+      end
+
+      # This checks if a given serialized value is valid for this field
+      def valid_input?(value, deep: true)
+        return false unless super
+        return null? if value.nil?
+        return valid_input_array?(value, deep) if array?
+
+        return true unless leaf_type? || deep
+        type_klass.valid_input?(value)
+      end
+
+      # Return the default value if the given +value+ is nil
+      def deserialize(value = nil)
+        value.nil? ? @default : super
+      end
+
+      # Checks if the default value of the field is valid
+      def validate!(*)
+        super if defined? super
+
+        raise ArgumentError, <<~MSG.squish unless type_klass.input_type?
+          The "#{type_klass.gql_name}" is not a valid input type.
+        MSG
+
+        raise ArgumentError, <<~MSG.squish unless default.nil? || valid_input?(default)
+          The given default value "#{default.inspect}" is not valid for this field.
+        MSG
+      end
+
+      protected
+
+        # Check if the given +value+ is a valid array as input
+        def valid_input_array?(value, deep)
+          return false unless value.is_a?(Array)
+
+          value.all? do |val|
+            (val.nil? && nullable?) || (leaf_type? || !deep) ||
+              type_klass.valid_input?(val)
+          end
+        end
+
+        # Display the default value when it is present for inspection
+        def inspect_default_value
+          " = #{to_hash.inspect}" if default?
+        end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # = GraphQL Output Field
+    #
+    # This is an extension of a normal output field, which just add extra
+    # validation and ensurance that the +perform+ step can be executed
+    class Field::MutationField < Field::OutputField
+      redefine_singleton_method(:mutation?) { true }
+
+      module Proxied # :nodoc: all
+        def performer
+          super || field.performer
+        end
+      end
+
+      # Add a block or a callable method that is executed before the resolver
+      # but after all the before resolve
+      def perform(*args, **xargs, &block)
+        @performer = Callback.new(self, :perform, *args, **xargs, &block)
+      end
+
+      # Get the performer that can be already defined or used through the
+      # +method_name+ if that is callable
+      def performer
+        @performer ||= callable?(method_name) \
+          ? Callback.new(self, :perform, method_name) \
+          : false
+      end
+
+      # Ensures that the performer is defined
+      def validate!(*)
+        super if defined? super
+
+        raise ValidationError, <<~MSG.squish unless performer.present?
+          The "#{gql_name}" mutation field must have a perform action through a given
+          block or a method named #{method_name} on #{owner.class.name}.
+        MSG
+      end
+
+      protected
+
+        def proxied # :nodoc:
+          super if defined? super
+          extend Field::MutationField::Proxied
+        end
+    end
+
+    Field::ScopedConfig.delegate :perform, to: :field
+  end
+end