rails-graphql 0.2.1 → 1.0.0.beta

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

@@ -1,35 +1,75 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = 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.
+    #
+    # ==== Options
+    #
+    # * <tt>:method_name</tt> - The name of the method used to fetch the field data
+    #   (defaults to nil).
+    # * <tt>:deprecated</tt> - A shortcut to adding a deprecated directive to the field
+    #   (defaults to nil).
     class Field::OutputField < Field
+      # Do not change this order because it can affect how events work. Callback
+      # must always come after events
       include Helpers::WithArguments
-      include Helpers::WithValidator
       include Helpers::WithEvents
       include Helpers::WithCallbacks
 
+      include Helpers::WithGlobalID
+      include Helpers::WithValidator
+
       include Field::AuthorizedField
       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)
+          inherited = field.all_arguments
+          return inherited unless defined?(@arguments)
+          inherited.blank? ? super : inherited + super
         end
 
         def has_argument?(name)
           super || field.has_argument?(name)
         end
+
+        def arguments?
+          super || field.arguments?
+        end
+
+        def all_events
+          if (inherited = super).nil?
+            field.all_events
+          elsif (proxied = field.all_events).nil?
+            inherited
+          else
+            Helpers.merge_hash_array(proxied, inherited)
+          end
+        end
+
+        def events?
+          super || field.events?
+        end
+
+        def all_listeners
+          if (inherited = super).nil?
+            field.all_listeners
+          elsif (proxied = field.all_listeners).nil?
+            inherited
+          else
+            proxied + inherited
+          end
+        end
+
+        def listeners?
+          super || field.listeners?
+        end
       end
 
       redefine_singleton_method(:output_type?) { true }
@@ -37,9 +77,10 @@ module Rails # :nodoc:
 
       def initialize(*args, method_name: nil, deprecated: false, **xargs, &block)
         @method_name = method_name.to_s.underscore.to_sym unless method_name.nil?
+        @broadcastable = xargs.delete(:broadcastable) if xargs.key?(:broadcastable)
 
         if deprecated.present?
-          xargs[:directives] = Array.wrap(xargs[:directives])
+          xargs[:directives] = ::Array.wrap(xargs[:directives])
           xargs[:directives] << Directive::DeprecatedDirective.new(
             reason: (deprecated.is_a?(String) ? deprecated : nil),
           )
@@ -48,12 +89,23 @@ module Rails # :nodoc:
         super(*args, **xargs, &block)
       end
 
+      # Accept changes to the method name through the +apply_changes+
+      def apply_changes(**xargs, &block)
+        @method_name = xargs.delete(:method_name) if xargs.key?(:method_name)
+        super
+      end
+
+      # By default, output fields that belongs to a schema is a query field
+      def schema_type
+        :query
+      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
+      # Checks if a given raw value is valid for this field
       def valid_output?(value, deep: true)
         return false unless super
         return null? if value.nil?
@@ -74,11 +126,43 @@ module Rails # :nodoc:
       def validate!(*)
         super if defined? super
 
-        raise ArgumentError, <<~MSG.squish unless type_klass.output_type?
+        raise ArgumentError, (+<<~MSG).squish unless type_klass.output_type?
           The "#{type_klass.gql_name}" is not a valid output type.
         MSG
       end
 
+      def all_events
+        if !defined?(@events) || !(local = @events).present?
+          super
+        elsif (inherited = super).nil?
+          local
+        else
+          Helpers.merge_hash_array(inherited, local)
+        end
+      end
+
+      def events?
+        super || defined?(@events) && @events.present?
+      end
+
+      def all_listeners
+        if !defined?(@listeners) || !(local = @listeners).present?
+          super
+        elsif (inherited = super).nil?
+          local
+        else
+          inherited + local
+        end
+      end
+
+      def listeners?
+        super || defined?(@listeners) && @listeners.present?
+      end
+
+      def broadcastable?
+        defined?(@broadcastable) && @broadcastable
+      end
+
       protected
 
         # Check if the given +value+ is a valid array as output
@@ -91,7 +175,12 @@ module Rails # :nodoc:
           end
         end
 
-        def proxied # :nodoc:
+        # Properly display the owner section when the field is owned by a Schema
+        def inspect_owner
+          owner.is_a?(Helpers::WithSchemaFields) ? +"#{owner.name}[:#{schema_type}]" : super
+        end
+
+        def proxied
           super if defined? super
           extend Field::OutputField::Proxied
         end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = GraphQL Proxied Field
     #
     # Proxied fields are a soft way to copy a real field. The good part is that
@@ -26,7 +26,7 @@ module Rails # :nodoc:
     module Field::ProxiedField
       delegate_missing_to :field
       delegate :leaf_type?, :array?, :internal?, :valid_input?, :valid_output?,
-        :to_json, :as_json, :deserialize, :valid?, to: :field
+        :to_json, :as_json, :deserialize, :valid?, :proxied_owner, to: :field
 
       Field.proxyable_methods %w[name gql_name method_name resolver description
         null? nullable? enabled?], klass: self
@@ -43,15 +43,22 @@ module Rails # :nodoc:
         true
       end
 
+      # Make sure to check the original field as well
+      # TODO: Maybe not use the +==+ method, but so far so good
+      def ==(other)
+        super || field == other
+      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] = ::Array.wrap(xargs[:directives])
           xargs[:directives] << Directive::DeprecatedDirective.new(
             reason: (deprecated.is_a?(String) ? deprecated : nil),
           )
         end
 
+        # TODO: Replace by a proper method to build and set @directives
         @directives = GraphQL.directives_to_set(xargs[:directives], source: self) \
           if xargs.key?(:directives)
 
@@ -63,11 +70,6 @@ module Rails # :nodoc:
         super
       end
 
-      # Return the original owner from +field+
-      def proxied_owner
-        field.owner
-      end
-
       # Override this to include proxied owners
       def all_owners
         super + proxied_owner.all_owners
@@ -78,34 +80,41 @@ module Rails # :nodoc:
         @field
       end
 
-      def disable! # :nodoc:
+      # Just ensure that when the field is proxied to an interface it does not
+      # allow disabling
+      def disable!
         super unless non_interface_proxy!('disable')
       end
 
-      def enable! # :nodoc:
+      # Just ensure that when the field is proxied to an interface it does not
+      # allow enabling
+      def enable!
         super unless non_interface_proxy!('enable')
       end
 
-      def all_directives # :nodoc:
-        field.all_directives + super
+      # Prepend the proxy directives and then the source directives
+      def all_directives
+        inherited = field.all_directives
+        return inherited unless defined?(@directives)
+        inherited.present? ? inherited + super : super
+      end
+
+      # Check if the field has directives locally or in the proxied field
+      def directives?
+        super || field.directives?
       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
+      # It is important to ensure that the proxied field is also valid
       def validate!(*)
         super if defined? super
-        field.validate! unless GraphQL.type_map.object_exist?(
-          proxied_owner,
-          namespaces: namespaces,
-          exclusive: true,
-        )
+        field.validate!
       end
 
       protected
 
         alias field proxied_field
 
-        def normalize_name(value) # :nodoc:
+        def normalize_name(value)
           super unless value.blank? || non_interface_proxy!('rename')
         end
 
@@ -124,7 +133,7 @@ module Rails # :nodoc:
 
         # Display the source of the proxy for inspection
         def inspect_source
-          "@source=#{proxied_owner.name}[:#{field.name}] [proxied]"
+          +"@source=#{field.owner.name}[:#{field.name}] [proxied]"
         end
 
         # This is trigerred when the field is proxied

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

@@ -1,23 +1,12 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # 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
@@ -65,26 +54,39 @@ module Rails # :nodoc:
 
         # Store this result for performance purposes
         @dynamic_resolver = dynamic_resolver?
-        return unless defined? @events
+        return unless defined?(@events)
 
-        invalid = @events.each_value.reject do |callback|
-          callback.block.is_a?(Proc) || callable?(callback.block)
-        end
+        # TODO: Change how events are validated. Relying on the +source_location
+        # uses inspect, which is not a good approach
+
+        # invalid = @events.each_pair.each_with_object({}) do |(key, events), hash|
+        #   events.each do |event|
+        #     _, method_name = event.source_location
+        #     next if method_name.nil? || callable?(method_name)
+
+        #     (hash[key] ||= []).push(method_name)
+        #   end
+        # end
+
+        # return if invalid.empty?
 
-        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
+        # invalid = invalid.map { |key, list| (+"#{key} => [#{list.join(', ')}]") }
+        # raise ArgumentError, (+<<~MSG).squish if invalid.present?
+        #   The "#{owner.name}" class does not define the following methods needed
+        #   for performing callbacks: #{invalid.join(', ')}.
+        # MSG
       end
 
       protected
 
-        # Chedck if a given +method_name+ is callable from the owner perspective
+        # Check if the method is defined and does not belong to a method defined
+        # by the gem itself
         def callable?(method_name)
-          owner.is_a?(Class) && owner.try(:gql_resolver?, method_name)
+          owner.is_a?(Class) && owner.public_method_defined?(method_name) &&
+            !owner.public_instance_method(method_name).owner.try(:abstract?)
         end
 
-        def proxied # :nodoc:
+        def proxied
           super if defined? super
           extend Field::ResolvedField::Proxied
         end

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

@@ -1,22 +1,28 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # 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
+    class Field::ScopedConfig < Struct.new(:field, :receiver)
       delegate :argument, :ref_argument, :id_argument, :use, :internal?, :disabled?,
         :enabled?, :disable!, :enable!, :authorize, to: :field
 
       delegate_missing_to :receiver
 
+      def rename!(name)
+        field.instance_variable_set(:@gql_name, name.to_s)
+      end
+
       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)
+        field.description = value
       end
+
+      alias description desc
     end
   end
 end

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    # = GraphQL Subscription Field
+    #
+    # TODO: Finish and add description
+    class Field::SubscriptionField < Field::OutputField
+      redefine_singleton_method(:subscription?) { true }
+      event_types(:subscribed, append: true)
+
+      attr_reader :prepare_context
+
+      module Proxied # :nodoc: all
+        def full_scope
+          field.full_scope + super
+        end
+
+        def prepare_context
+          super || field.prepare_context
+        end
+      end
+
+      # Change the schema type of the field
+      def schema_type
+        :subscription
+      end
+
+      # A kind of alias to the subscribe event available
+      def subscribed(*args, **xargs, &block)
+        on(:subscribed, *args, **xargs, &block)
+        self
+      end
+
+      # Set the parts of the scope of the subscription
+      def scope(*parts)
+        (defined?(@scope) ? (@scope += parts) : (@scope = parts)).freeze
+      end
+
+      # Get the full scope of the field
+      def full_scope
+        return EMPTY_ARRAY unless defined?(@scope)
+      end
+
+      # Checks if the scope is correctly defined
+      def validate!(*)
+        super if defined? super
+        return unless defined?(@scope)
+
+        invalid = @scope.reject { |item| item.is_a?(Symbol) || item.is_a?(Proc) }
+        raise ArgumentError, (+<<~MSG).squish if invalid.any?
+          The "#{type_klass.gql_name}" has invalid values set for its scope: #{invalid.inspect}.
+        MSG
+      end
+
+      # A shortcut for trigger when everything is related to the provided object
+      # TODO: Maybe add support for object as an array of things
+      # TODO: Add support for +data_for+. The only problem right now is that
+      # providers run asynchronously, so passing data is a bit more complicated
+      # and maybe dangerous (size speaking)
+      def trigger_for(object, **xargs)
+        match_valid_object!(object)
+        xargs[:args] ||= extract_args_from(object)
+        trigger(**xargs)
+      end
+
+      # A shortcut for unsubscribe when everything is related to the provided
+      # object
+      # TODO: Maybe add support for object as an array of things
+      def unsubscribe_from(object, **xargs)
+        match_valid_object!(object)
+        xargs[:args] ||= extract_args_from(object)
+        unsubscribe(**xargs)
+      end
+
+      # Trigger an update to the subscription
+      def trigger(args: nil, scope: nil)
+        provider = owner.subscription_provider
+        provider.search_and_update(field: self, args: args, scope: scope)
+      end
+
+      # Force matching subscriptions to be removed
+      def unsubscribe(args: nil, scope: nil)
+        provider = owner.subscription_provider
+        provider.search_and_remove(field: self, args: args, scope: scope)
+      end
+
+      protected
+
+        # Match any argument with properties from the given +object+ so it
+        # produces all the possibilities of an update
+        def extract_args_from(object)
+          return unless arguments?
+
+          # Prepare all the possibilities
+          keys = []
+          hash_like = object.respond_to?(:[])
+          possibilities = all_arguments.each_value.with_object([]) do |arg, list|
+            keys << arg.name
+            list << []
+
+            value =
+              if object.respond_to?(arg.name)
+                object.public_send(arg.name)
+              elsif hash_like && (object.key?(arg.name) || object.key?(arg.name.to_s))
+                object[arg.name] || arg.name[arg.name.to_s]
+              end
+
+            list.last << value unless value.nil?
+            list.last << nil if arg.null?
+          end
+
+          # Now turn them into actual possible args
+          possibilities.reduce(:product).flatten.each_slice(keys.size).map do |items|
+            keys.zip(items).to_h
+          end
+        end
+
+        # Check if the provided +object+ is a match for the type that this field
+        # is associated with
+        def match_valid_object!(object)
+          raise ::ArgumentError, (+<<~MSG).squish unless type_klass&.object?
+            Cannot trigger with an object when the field is not associated to
+            an object-like result.
+          MSG
+
+          assignable = !object.is_a?(Module) && type_klass.valid_member?(object)
+          raise ::ArgumentError, (+<<~MSG).squish unless assignable
+            The provided object "#{object.inspect}" is not a valid member of
+            #{type_klass.inspect} for the :#{name} field.
+          MSG
+        end
+
+        def proxied
+          super if defined? super
+          extend Field::SubscriptionField::Proxied
+        end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # This is a helper module that basically works with fields that have an
     # assigned type value
     module Field::TypedField
@@ -14,13 +14,7 @@ module Rails # :nodoc:
       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
-
+        assign_type(type)
         super(name, *args, **xargs, &block)
       end
 
@@ -36,7 +30,7 @@ module Rails # :nodoc:
       end
 
       # Sometimes the owner does not designate this, but it is safe to assume it
-      # will be associated to the object valyd types
+      # will be associated to the object valid types
       def valid_field_types
         owner.try(:valid_field_types) || Type::Object.valid_field_types
       end
@@ -57,27 +51,42 @@ module Rails # :nodoc:
 
       # Add the listeners from the associated type
       def all_listeners
-        type_klass.all_listeners + super
+        inherited = super
+        return inherited unless type_klass.listeners?
+        inherited.present? ? inherited + type_klass.all_listeners : type_klass.all_listeners
+      end
+
+      # Make sure to check the associated type
+      def listeners?
+        super || type_klass.listeners?
       end
 
       # Add the events from the associated type
       def all_events
-        Helpers.merge_hash_array(type_klass.all_events, super)
+        inherited = super
+        return inherited unless type_klass.events?
+        return type_klass.all_events if inherited.blank?
+        Helpers.merge_hash_array(inherited, type_klass.all_events)
+      end
+
+      # Make sure to check the associated type
+      def events?
+        super || type_klass.events?
       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.
+        raise ArgumentError, (+<<~MSG).squish unless type_klass.is_a?(Module)
+          Unable to find the "#{type.inspect}" data 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
+        raise ArgumentError, (+<<~MSG).squish unless valid_type
           The "#{type_klass.base_type}" is not accepted in this context.
         MSG
       end
@@ -86,16 +95,28 @@ module Rails # :nodoc:
 
         # 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 = +': '
+          result << '[' if array?
+          result << type_klass.gql_name
+          result << '!' if array? && !nullable?
+          result << ']' if array?
+          result << '!' unless null?
           result
         end
 
-        def proxied # :nodoc:
+        # A little hidden helper to support forcing reassignment of type, which
+        # should only be done with caution
+        def assign_type(type)
+          if type.is_a?(Module) && type < GraphQL::Type
+            @type_klass = type
+            @type = type.to_sym
+          else
+            @type_klass = nil
+            @type = type
+          end
+        end
+
+        def proxied
           super if defined? super
           extend Field::TypedField::Proxied
         end