rails-graphql 0.2.1 → 1.0.0.rc1

data/lib/rails/graphql/directive.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = GraphQL Directive
     #
     # This is the base object for directives definition.
@@ -22,24 +22,38 @@ module Rails # :nodoc:
     #   add :old_value, directives: DeprecatedDirective(reason: 'not used anymore')
     class Directive
       extend ActiveSupport::Autoload
-      extend Helpers::InheritedCollection
       extend Helpers::WithEvents
       extend Helpers::WithCallbacks
       extend Helpers::WithArguments
+      extend Helpers::WithGlobalID
       extend Helpers::Registerable
 
-      VALID_LOCATIONS = Rails::GraphQL::Type::Enum::DirectiveLocationEnum
-        .values.to_a.map { |value| value.downcase.to_sym }.freeze
+      EXECUTION_LOCATIONS  = %i[
+        query mutation subscription field fragment_definition fragment_spread inline_fragment
+      ].to_set.freeze
 
-      EXECUTION_LOCATIONS  = VALID_LOCATIONS[0..6].freeze
-      DEFINITION_LOCATIONS = VALID_LOCATIONS[7..17].freeze
+      DEFINITION_LOCATIONS = %i[
+        schema scalar object field_definition argument_definition interface union
+        enum enum_value input_object input_field_definition
+      ].to_set.freeze
+
+      VALID_LOCATIONS = (EXECUTION_LOCATIONS + DEFINITION_LOCATIONS).freeze
 
       class << self
-        def kind # :nodoc
+        def kind
           :directive
         end
 
-        def gql_name # :nodoc:
+        # Ensure to return the directive class
+        def base_type
+          GraphQL::Directive
+        end
+
+        alias gid_base_class base_type
+
+        # Return the name of the object as a GraphQL name, ensure to use the
+        # first letter as lower case when being auto generated
+        def gql_name
           return @gql_name if defined?(@gql_name)
           @gql_name = super.camelize(:lower)
         end
@@ -64,33 +78,36 @@ module Rails # :nodoc:
           @locations = list.to_set
         end
 
-        def eager_load! # :nodoc:
-          super
+        # A helper method that allows directives to be initialized while
+        # correctly parsing the arguments
+        def build(**xargs)
+          xargs = xargs.stringify_keys
+          result = all_arguments&.each&.each_with_object({}) do |(name, argument), hash|
+            hash[name] = argument.deserialize(xargs[argument.gql_name] || xargs[name.to_s])
+          end
 
-          TypeMap.loaded! :Directive
+          new(**result)
         end
 
-        def inspect # :nodoc:
-          return '#<GraphQL::Directive>' if eql?(GraphQL::Directive)
+        # Return the directive, instantiate if it has params
+        def find_by_gid(gid)
+          options = { namespaces: gid.namespace, base_class: :Directive }
+          klass = GraphQL.type_map.fetch!(gid.name, **options)
+          gid.instantiate? ? klass.build(**gid.params) : klass
+        end
 
-          args = arguments.each_value.map(&:inspect)
+        def inspect
+          return super if eql?(GraphQL::Directive)
+
+          repeatable = ' [repeatable]' if repeatable?
+          args = all_arguments&.each_value&.map(&:inspect)
+          args = args.force if args.respond_to?(:force)
           args = args.presence && "(#{args.join(', ')})"
-          "#<GraphQL::Directive @#{gql_name}#{args}>"
+          +"#<GraphQL::Directive @#{gql_name}#{repeatable}#{args}>"
         end
 
         private
 
-          # Check if the given list the locations are valid
-          def validate_locations!(list)
-            list.flatten!
-            list.map! { |item| item.to_s.underscore.to_sym }
-
-            invalid = list - VALID_LOCATIONS
-            raise ArgumentError, <<~MSG.squish unless invalid.empty?
-              Invalid locations for @#{gql_name}: #{invalid.to_sentence}.
-            MSG
-          end
-
           # Provide a nice way to use a directive without calling
           # +Directive.new+, like the +DeprecatedDirective+ can be initialized
           # using +GraphQL::DeprecatedDirective(*args)+
@@ -105,54 +122,58 @@ module Rails # :nodoc:
             end
           end
 
-          # Allows checking value existence
-          def respond_to_missing?(method_name, *)
-            (const_defined?(method_name) rescue nil) || autoload?(method_name) || super
+          # A helper method that allows the +on+ and +for+ event filters to be
+          # used with things from both the TypeMap and the GraphQL shortcut
+          # classes
+          def sanitize_objects(setting)
+            GraphQL.enumerate(setting).map do |item|
+              next item unless item.is_a?(String) || item.is_a?(Symbol)
+              GraphQL.type_map.fetch(item, namespaces: namespaces) ||
+                ::GraphQL.const_get(item)
+            end
           end
 
-          # Allow fast creation of values
-          def method_missing(method_name, *args, **xargs, &block)
-            const_get(method_name)&.new(*args, **xargs, &block) || super
-          rescue ::NameError
-            super
+          # Check if the given list the locations are valid
+          def validate_locations!(list)
+            invalid = list.flatten.lazy.reject do |item|
+              item = item.to_s.underscore.to_sym unless item.is_a?(Symbol)
+              VALID_LOCATIONS.include?(item)
+            end
+
+            raise ArgumentError, (+<<~MSG).squish if invalid.any?
+              Invalid locations for @#{gql_name}: #{invalid.force.to_sentence}.
+            MSG
           end
       end
 
-      self.abstract = true
+      # Marks if the directive may be used repeatedly at a single location
+      class_attribute :repeatable, instance_accessor: false, default: false
 
-      eager_autoload do
-        autoload :DeprecatedDirective
-        autoload :IncludeDirective
-        autoload :SkipDirective
-      end
+      self.abstract = true
 
-      delegate :locations, :gql_name, to: :class
+      autoload :DeprecatedDirective
+      autoload :IncludeDirective
+      autoload :SkipDirective
+      autoload :SpecifiedByDirective
 
-      array_sanitizer = ->(setting) do
-        Array.wrap(setting)
-      end
+      autoload :CachedDirective
 
-      object_sanitizer = ->(setting) do
-        Array.wrap(setting).map! do |item|
-          next item unless item.is_a?(String) || item.is_a?(Symbol)
-          GraphQL.type_map.fetch(item, namespaces: namespaces) ||
-            ::GraphQL.const_get(item)
-        end
-      end
+      delegate :locations, :gql_name, :gid_base_class, :repeatable?, to: :class
 
-      event_filter(:for, object_sanitizer) do |options, event|
-        options.any?(&event.source.method(:of_type?))
+      # TODO: This filters are a bit confusing now, but `for` is working for @deprecated
+      event_filter(:for) do |options, event|
+        sanitize_objects(options).any?(&event.source.method(:of_type?))
       end
 
-      event_filter(:on, object_sanitizer) do |options, event|
-        event.respond_to?(:on?) && options.any?(&event.method(:on?))
+      event_filter(:on) do |options, event|
+        event.respond_to?(:on?) && sanitize_objects(options).any?(&event.method(:on?))
       end
 
-      event_filter(:during, array_sanitizer) do |options, event|
-        event.key?(:phase) && options.include?(event[:phase])
+      event_filter(:during) do |options, event|
+        event.key?(:phase) && GraphQL.enumerate(options).include?(event[:phase])
       end
 
-      attr_reader :args
+      attr_reader :args, :event
 
       def initialize(args = nil, **xargs)
         @args = args || OpenStruct.new(xargs.transform_keys { |key| key.to_s.underscore })
@@ -160,44 +181,84 @@ module Rails # :nodoc:
       end
 
       # Once the directive is correctly prepared, we need to assign the owner
-      def assing_owner!(owner)
-        raise ArgumentError, <<~MSG.squish if defined?(@owner)
+      def assign_owner!(owner)
+        raise ArgumentError, (+<<~MSG).squish if defined?(@owner)
           Owner already assigned for @#{gql_name} directive.
         MSG
 
         @owner = owner
       end
 
+      # Correctly turn all the arguments into their +as_json+ version and return
+      # a hash of them
+      def args_as_json
+        all_arguments&.each&.with_object({}) do |(name, argument), hash|
+          hash[argument.gql_name] = argument.as_json(@args[name])
+        end
+      end
+
+      # Correctly turn all the arguments into their +to_json+ version and return
+      # a hash of them
+      def args_to_json
+        all_arguments&.each&.with_object({}) do |(name, argument), hash|
+          hash[argument.gql_name] = argument.to_json(@args[name])
+        end
+      end
+
       # When fetching all the events, embed the actual instance as the context
       # of the callback
+      # TODO: Maybe add a soft cached, based on the total number of events
       def all_events
-        @all_events ||= self.class.all_events.transform_values do |events|
+        return unless self.class.events?
+
+        self.class.all_events.transform_values do |events|
           events.map { |item| Callback.set_context(item, self) }
         end
       end
 
       # Checks if all the arguments provided to the directive instance are valid
       def validate!(*)
-        invalid = all_arguments.reject { |name, arg| arg.valid?(@args[name]) }
-        return if invalid.empty?
+        raise ArgumentError, (+<<~MSG).squish unless defined?(@owner)
+          The @#{gql_name} directive is unbounded.
+        MSG
+
+        invalid = all_arguments&.reject { |name, arg| arg.valid?(@args[name]) }
+        return if invalid.blank?
 
-        invalid = invalid.map { |name, _| <<~MSG }
-          Invalid value "#{@args[name].inspect}" for #{name} argument.
+        invalid = invalid.each_key.map { |name| (+<<~MSG).squish }
+          invalid value "#{@args[name].inspect}" for #{name} argument
         MSG
 
-        raise ArgumentError, <<~MSG.squish
+        raise ArgumentError, (+<<~MSG).squish
           Invalid usage of @#{gql_name} directive: #{invalid.to_sentence}.
         MSG
       end
 
-      def inspect # :nodoc:
-        args = all_arguments.map do |name, arg|
-          "#{arg.gql_name}: #{@args[name].inspect}" unless @args[name].nil?
-        end.compact
+      # This allows combining directives
+      def +(other)
+        [self, other].flatten
+      end
+
+      alias_method :&, :+
+
+      def inspect
+        args = all_arguments&.filter_map do |name, arg|
+          +"#{arg.gql_name}: #{@args[name].inspect}" unless @args[name].nil?
+        end
 
-        args = args.presence && "(#{args.join(', ')})"
-        "@#{gql_name}#{args}"
+        args = args.presence && +"(#{args.join(', ')})"
+        repeatable = ' [repeatable]' if repeatable?
+        unbound = ' # unbound' unless defined?(@owner)
+        +"@#{gql_name}#{repeatable}#{args}#{unbound}"
       end
+
+      %i[to_global_id to_gid to_gid_param].each do |method_name|
+        define_method(method_name) do
+          # TODO: The option is kind of broken, because they should always be a Hash
+          self.class.public_send(method_name, args_as_json&.compact || '')
+        end
+      end
+
     end
   end
 end

data/lib/rails/graphql/errors.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    # Error class tha wrappes all the other error classes
+module Rails
+  module GraphQL
+    # Error class tha wraps all the other error classes
     StandardError = Class.new(::StandardError)
 
     # Error class related to problems during the definition process
@@ -14,10 +14,13 @@ module Rails # :nodoc:
     # Errors that can happen related to the arguments given to a method
     ArgumentError = Class.new(DefinitionError)
 
+    # Errors that can happen when locking for definition objects, like fields
+    NotFoundError = Class.new(DefinitionError)
+
     # Errors related to the name of the objects
     NameError = Class.new(DefinitionError)
 
-    # Errors related to duplciated objects
+    # Errors related to duplicated objects
     DuplicatedError = Class.new(NameError)
 
     # Error class related to problems during the execution process
@@ -26,6 +29,9 @@ module Rails # :nodoc:
     # Error related to the parsing process
     ParseError = Class.new(ExecutionError)
 
+    # Error class related to parsing the arguments
+    ArgumentsError = Class.new(ParseError)
+
     # Error class related to problems that happened during execution of fields
     FieldError = Class.new(ExecutionError)
 
@@ -42,5 +48,28 @@ module Rails # :nodoc:
     # Error class related to when a field is unauthorized and can not be used,
     # similar to disabled fields
     UnauthorizedFieldError = Class.new(FieldError)
+
+    # Error class related to problems that happened while subscribing to a field
+    SubscriptionError = Class.new(FieldError)
+
+    # Error class related to execution responses that don't require processing
+    StaticResponse = Class.new(Interrupt)
+
+    # Error class related to cached responses, which doesn't need processing
+    CachedResponse = Class.new(StaticResponse)
+
+    # Error class related to a persisted query that has't been persisted yet
+    PersistedQueryNotFound = Class.new(StaticResponse)
+
+    # A simple module and way to extend errors with extra information
+    ExtendedError = Module.new do
+      delegate_missing_to :@extension
+
+      def self.extend(error, extension)
+        error.instance_variable_set(:@extension, extension)
+        error.extend(self)
+        error
+      end
+    end
   end
 end

data/lib/rails/graphql/event.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = GraphQL Event
     #
-    # This class is responsible for trigerring events. It also contains the
+    # This class is responsible for triggering events. It also contains the
     # +data+ that can be used on the event handlers.
     class Event
-      attr_reader :source, :data, :name, :object, :last_result
+      attr_reader :source, :data, :event_name, :object, :last_result
 
       alias event itself
 
@@ -34,12 +34,23 @@ module Rails # :nodoc:
         @collect = data.delete(:collect?)
         @reverse = data.delete(:reverse?)
 
-        @name = name
+        @event_name = name
         @data = data
         @source = source
         @layers = []
       end
 
+      # Check if the provided +other+ is equal to the source of the event. If
+      # other is a directive, then check if the source is using that directive
+      # TODO: Other cannot be an instance
+      def same_source?(other)
+        if other.is_a?(Directive) || (other.is_a?(Module) && other < Directive)
+          event_name == :attach || source.using?(other)
+        else
+          source == other
+        end
+      end
+
       # Return a given +name+ information from the event
       def parameter(name)
         respond_to?(name) ? public_send(name) : data[name]
@@ -71,10 +82,13 @@ module Rails # :nodoc:
         end
       end
 
+      alias on_instance set_on
+
       # From the list of all given objects, run the +trigger_object+
       def trigger_all(*objects)
         catchable(:stack) do
           iterator = @collect ? :map : :each
+          objects = objects.first if objects.size == 1 && objects.first.is_a?(Enumerable)
           objects.flatten.send(iterator, &method(:trigger_object))
         end
       end
@@ -91,7 +105,7 @@ module Rails # :nodoc:
         old_items, old_object, old_result, @object = @items, @object, @last_result, object
 
         catchable(:object) do
-          events ||= object.all_events[name]
+          events ||= object.all_events.try(:[], event_name)
           stop if events.blank?
 
           @items = @reverse ? events.reverse_each : events.each
@@ -125,8 +139,6 @@ module Rails # :nodoc:
         # Do not do anything when missing next/super
       end
 
-      alias call_super call_next
-
       protected
 
         alias args_source itself
@@ -138,7 +150,7 @@ module Rails # :nodoc:
           @layers.unshift(layer)
           catch(layer) { yield }
         ensure
-          @layers.pop
+          @layers.shift
         end
 
         # Check for data based readers

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

@@ -1,14 +1,19 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # This provides ways for fields to be authorized, giving a logical level for
     # enabling or disabling access to a field. It has a similar structure to
     # events, but has a different hierarchy of resolution
     module Field::AuthorizedField
-      # Just add the callbacks setup to the field
-      def self.included(other)
-        other.event_types(:authorize, append: true)
+      module Proxied # :nodoc: all
+        def authorizer
+          super || field.authorizer
+        end
+
+        def authorizable?
+          super || field.authorizable?
+        end
       end
 
       # Add either settings for authorization or a block to be executed. It
@@ -27,7 +32,13 @@ module Rails # :nodoc:
       def authorizable?
         defined?(@authorizer)
       end
+
+      protected
+
+        def proxied
+          super if defined? super
+          extend Field::AuthorizedField::Proxied
+        end
     end
   end
 end
-#

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = GraphQL Input Field
     #
     # An input field works the same way as an argument and they are pretty much
@@ -13,8 +13,6 @@ module Rails # :nodoc:
     # ==== 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
 
@@ -25,11 +23,9 @@ module Rails # :nodoc:
 
       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'
+        @default = default
+        @default = deserialize(@default) if @default.is_a?(::GQLParser::Token)
       end
 
       # Allow change the default value for the input
@@ -72,11 +68,11 @@ module Rails # :nodoc:
       def validate!(*)
         super if defined? super
 
-        raise ArgumentError, <<~MSG.squish unless type_klass.input_type?
+        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)
+        raise ArgumentError, (+<<~MSG).squish unless default.nil? || valid_input?(default)
           The given default value "#{default.inspect}" is not valid for this field.
         MSG
       end
@@ -85,7 +81,7 @@ module Rails # :nodoc:
 
         # Check if the given +value+ is a valid array as input
         def valid_input_array?(value, deep)
-          return false unless value.is_a?(Array)
+          return false unless value.is_a?(::Array)
 
           value.all? do |val|
             (val.nil? && nullable?) || (leaf_type? || !deep) ||
@@ -95,7 +91,7 @@ module Rails # :nodoc:
 
         # Display the default value when it is present for inspection
         def inspect_default_value
-          " = #{to_hash.inspect}" if default?
+          +" = #{as_json.inspect}" if default_value?
         end
     end
   end

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

@@ -1,11 +1,16 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    # = GraphQL Output Field
+module Rails
+  module GraphQL
+    # = GraphQL Mutation Field
     #
     # This is an extension of a normal output field, which just add extra
-    # validation and ensurance that the +perform+ step can be executed
+    # validation and insurance that the +perform+ step can be executed
+    #
+    # ==== Options
+    #
+    # * <tt>:call</tt> - The alternative method to call to actually perform the mutation.
+    #   (defaults to nil).
     class Field::MutationField < Field::OutputField
       redefine_singleton_method(:mutation?) { true }
 
@@ -15,6 +20,34 @@ module Rails # :nodoc:
         end
       end
 
+      # Intercept the initializer to maybe set the +perform_method_name+
+      def initialize(*args, call: nil, **xargs, &block)
+        @perform_method_name = call.to_sym unless call.nil?
+        super(*args, **xargs, &block)
+      end
+
+      # Accept changes to the perform method name through the +apply_changes+
+      def apply_changes(**xargs, &block)
+        @perform_method_name = xargs.delete(:call) if xargs.key?(:call)
+        super
+      end
+
+      # Allows overrides for the default bang method
+      def perform_method_name
+        if defined?(@perform_method_name)
+          @perform_method_name
+        elsif from_alternative?
+          :perform
+        else
+          :"#{method_name}!"
+        end
+      end
+
+      # Change the schema type of the field
+      def schema_type
+        :mutation
+      end
+
       # Add a block or a callable method that is executed before the resolver
       # but after all the before resolve. It returns +self+ for chain purposes
       def perform(*args, **xargs, &block)
@@ -25,16 +58,17 @@ module Rails # :nodoc:
       # 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
+        return @performer if defined?(@performer)
+
+        @performer = callable?(perform_method_name)
+        @performer = Callback.new(self, :perform, perform_method_name) if @performer
       end
 
       # Ensures that the performer is defined
       def validate!(*)
         super if defined? super
 
-        raise ValidationError, <<~MSG.squish unless performer.present?
+        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
@@ -42,7 +76,7 @@ module Rails # :nodoc:
 
       protected
 
-        def proxied # :nodoc:
+        def proxied
           super if defined? super
           extend Field::MutationField::Proxied
         end