rails-graphql 0.2.1 → 1.0.0.rc1

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

@@ -1,35 +1,82 @@
 # 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
+        Field.proxyable_methods %w[broadcastable?], klass: self
 
         def all_arguments
-          field.arguments.merge(super)
+          inherited = field.all_arguments
+          return inherited unless defined?(@arguments)
+          inherited.blank? ? super : inherited.merge(super)
         end
 
         def has_argument?(name)
           super || field.has_argument?(name)
         end
+
+        def arguments?
+          super || field.arguments?
+        end
+
+        # TODO: Break events into directive/type/local
+        # because type events should only be added
+        # from the proxy
+        def all_events
+          if (inherited = super).nil?
+            field.all_events
+          elsif (proxied = field.all_events).nil?
+            inherited
+          else
+            # The order is reversed because events from
+            # the proxy must come first
+            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 +84,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 +96,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 +133,47 @@ 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
+
+      def entry_point?
+        owner.is_a?(Helpers::WithSchemaFields)
+      end
+
       protected
 
         # Check if the given +value+ is a valid array as output
@@ -91,7 +186,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
+          entry_point? ? +"#{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
@@ -25,10 +25,9 @@ module Rails # :nodoc:
     # * <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
+      delegate :leaf_type?, :array?, :internal?, :proxied_owner, to: :field
 
-      Field.proxyable_methods %w[name gql_name method_name resolver description
+      Field.proxyable_methods %w[name gql_name method_name description
         null? nullable? enabled?], klass: self
 
       def initialize(field, owner:, **xargs, &block)
@@ -43,19 +42,27 @@ module Rails # :nodoc:
         true
       end
 
-      # Allow chaging most of the general kind-independent initialize settings
+      # 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 changing 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)
 
-        @desc    = xargs[:desc]&.strip_heredoc&.chomp if xargs.key?(:desc)
+        self.description = xargs[:desc] if xargs.key?(:desc)
+        self.description = xargs[:description] if xargs.key?(:description)
         @enabled = xargs.fetch(:enabled, !xargs.fetch(:disabled, false)) \
           if xargs.key?(:enabled) || xargs.key?(:disabled)
 
@@ -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
@@ -29,7 +18,7 @@ module Rails # :nodoc:
 
       # Just add the callbacks setup to the field
       def self.included(other)
-        other.event_types(:prepare, :finalize, append: true, expose: true)
+        other.send(:expose_events!, :organized, :finalize, :prepared, :prepare)
         other.alias_method(:before_resolve, :prepare)
         other.alias_method(:after_resolve, :finalize)
       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,123 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    # = GraphQL Subscription Field
+    #
+    # This is an extension of a normal output field, which will sign
+    # the request for updates of the field when the scope and arguments
+    # are the same.
+    class Field::SubscriptionField < Field::OutputField
+      redefine_singleton_method(:subscription?) { true }
+      event_types(:subscribed, append: true)
+
+      module Proxied # :nodoc: all
+        def full_scope
+          field.full_scope + super
+        end
+      end
+
+      # Just add the callbacks setup to the field
+      def self.included(other)
+        other.send(:expose_events!, :subscribed)
+      end
+
+      # Intercept the initializer to maybe set the +scope+
+      def initialize(*args, scope: nil, **xargs, &block)
+        @scope = Array.wrap(scope).freeze unless scope.nil?
+        super(*args, **xargs, &block)
+      end
+
+      # Change the schema type of the field
+      def schema_type
+        :subscription
+      end
+
+      # Set the parts of the scope of the subscription
+      def scope(*parts)
+        (defined?(@scope) ? (@scope += parts) : (@scope = parts)).freeze
+        self
+      end
+
+      # Get the full scope of the field
+      def full_scope
+        defined?(@scope) ? @scope : EMPTY_ARRAY
+      end
+
+      # A shortcut for trigger when everything is related to the provided object
+      def trigger_for(object, and_prepare: true, **xargs)
+        xargs[:args] ||= extract_args_from(object)
+
+        if and_prepare
+          xargs[:data_for] ||= {}
+          xargs[:data_for][+"subscription.#{gql_name}"] = object
+        end
+
+        trigger(**xargs)
+      end
+
+      # A shortcut for unsubscribe when everything is related to the provided
+      # object
+      def unsubscribe_from(object, **xargs)
+        xargs[:args] ||= extract_args_from(object)
+        unsubscribe(**xargs)
+      end
+
+      # Trigger an update to the subscription
+      def trigger(**xargs)
+        provider = owner.subscription_provider
+        provider.search_and_update(field: self, **xargs)
+      end
+
+      # Force matching subscriptions to be removed
+      def unsubscribe(**xargs)
+        provider = owner.subscription_provider
+        provider.search_and_remove(field: self, **xargs)
+      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, iterate = true)
+          return unless arguments?
+
+          # If can iterate and the provided object is an enumerable, then
+          # call itself with each item
+          if iterate && object.is_a?(Enumerable)
+            return object.each_with_object([]) do |item, result|
+              result.concat(extract_args_from(item, false))
+            end
+          end
+
+          # 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
+
+        def proxied
+          super if defined? super
+          extend Field::SubscriptionField::Proxied
+        end
+    end
+  end
+end