rails-graphql 1.0.0.beta → 1.0.0.rc1

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

@@ -4,21 +4,28 @@ module Rails
   module GraphQL
     # = GraphQL Subscription Field
     #
-    # TODO: Finish and add description
+    # 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)
 
-      attr_reader :prepare_context
-
       module Proxied # :nodoc: all
         def full_scope
           field.full_scope + super
         end
+      end
 
-        def prepare_context
-          super || field.prepare_context
-        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
@@ -26,72 +33,63 @@ module Rails
         :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
+        self
       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
+        defined?(@scope) ? @scope : EMPTY_ARRAY
       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)
+      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
-      # 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)
+      def trigger(**xargs)
         provider = owner.subscription_provider
-        provider.search_and_update(field: self, args: args, scope: scope)
+        provider.search_and_update(field: self, **xargs)
       end
 
       # Force matching subscriptions to be removed
-      def unsubscribe(args: nil, scope: nil)
+      def unsubscribe(**xargs)
         provider = owner.subscription_provider
-        provider.search_and_remove(field: self, args: args, scope: scope)
+        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)
+        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?(:[])
@@ -116,21 +114,6 @@ module Rails
           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

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

@@ -13,7 +13,8 @@ module Rails
 
       delegate :input_type?, :output_type?, :leaf_type?, :kind, to: :type_klass
 
-      def initialize(name, type, *args, **xargs, &block)
+      def initialize(name, type = nil, *args, **xargs, &block)
+        type = (name == :id ? :id : :string) if type.nil?
         assign_type(type)
         super(name, *args, **xargs, &block)
       end
@@ -26,7 +27,7 @@ module Rails
 
       # Check if types are compatible
       def =~(other)
-        other.is_a?(Field::TypedField) && other.type_klass =~ type_klass && super
+        super && other.is_a?(Field::TypedField) && other.type_klass =~ type_klass
       end
 
       # Sometimes the owner does not designate this, but it is safe to assume it
@@ -49,6 +50,8 @@ module Rails
         )
       end
 
+      alias type_class type_klass
+
       # Add the listeners from the associated type
       def all_listeners
         inherited = super
@@ -74,6 +77,27 @@ module Rails
         super || type_klass.events?
       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
+
       # Checks if the type of the field is valid
       def validate!(*)
         super if defined? super

data/lib/rails/graphql/field.rb

@@ -22,7 +22,7 @@ module Rails
     #   (defaults to false).
     # * <tt>:enabled</tt> - Mark the field as enabled
     #   (defaults to true).
-    # * <tt>:disabled</tt> - Works as the oposite of the enabled option
+    # * <tt>:disabled</tt> - Works as the opposite of the enabled option
     #   (defaults to false).
     # * <tt>:directives</tt> - The list of directives associated with the value
     #   (defaults to nil).
@@ -117,7 +117,7 @@ module Rails
         @array    = full ? true  : xargs.fetch(:array, false)
         @nullable = full ? false : xargs.fetch(:nullable, true)
 
-        self.description = xargs[:desc]
+        self.description = xargs[:desc] || xargs[:description]
         @enabled = xargs.fetch(:enabled, !xargs.fetch(:disabled, false))
 
         configure(&block) if block.present?
@@ -137,12 +137,14 @@ module Rails
         enable! if xargs.fetch(:enabled, false)
 
         self.description = xargs[:desc] if xargs.key?(:desc)
+        self.description = xargs[:description] if xargs.key?(:description)
         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)
+        self
       end
 
       # Return the owner as the single item of the list
@@ -181,17 +183,22 @@ module Rails
         @nullable = false
       end
 
-      # Checks if the argument can be null
+      # Checks if the field can be null
       def null?
         !!@null
       end
 
-      # Checks if the argument can be an array
+      # Checks if the field cannot br null
+      def required?
+        !null?
+      end
+
+      # Checks if the field can be an array
       def array?
         !!@array
       end
 
-      # Checks if the argument can have null elements in the array
+      # Checks if the field can have null elements in the array
       def nullable?
         !!@nullable
       end
@@ -227,24 +234,18 @@ module Rails
       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) }
+      def to_json(*)
+        raise NotImplementedError, +"#{self.class.name} does not implement to_json"
       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) }
+      def as_json(*)
+        raise NotImplementedError, +"#{self.class.name} does not implement as_json"
       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? }
+      def deserialize(*)
+        raise NotImplementedError, +"#{self.class.name} does not implement deserialize"
       end
 
       # Check if the given value is valid using +valid_input?+ or
@@ -282,8 +283,8 @@ module Rails
 
       def inspect
         (+<<~INFO).squish << '>'
-          #<#{self.class.name}
-          #{inspect_owner}
+          #<GraphQL::#{self.class.name.split('::').last}
+          #{inspect_owner&.split(+'GraphQL::')&.last&.sub(+'::NestedTypes', '')}
           #{inspect_source}
           #{inspect_enabled}
           #{gql_name}#{inspect_arguments}#{inspect_type}

data/lib/rails/graphql/global_id.rb

@@ -72,7 +72,11 @@ module Rails
       end
 
       def base_class
-        ::GraphQL.const_get(class_name, false)
+        if %w[Schema Directive Type].include?(class_name)
+          GraphQL.const_get(class_name, false)
+        else
+          GraphQL.type_map.fetch(class_name, namespace: namespace)
+        end
       end
 
       def ==(other)

data/lib/rails/graphql/helpers/inherited_collection/array.rb

@@ -4,6 +4,7 @@ module Rails
       # A inherited collection of arrays that can be unique when it is a set
       class InheritedCollection::Array < InheritedCollection::Base
         alias size count
+        alias to_ary eager
 
         # Provide similar functionality of any? but returns the object instead
         def find(value = nil, &block)

data/lib/rails/graphql/helpers/inherited_collection/base.rb

@@ -7,6 +7,8 @@ module Rails
       class InheritedCollection::Base
         include Enumerable
 
+        delegate :eager, to: :each
+
         # Just a little helper to initialize the iterator form a given +source+
         def self.handle(source, ivar, type)
           klass = (type == :array || type == :set) ? :Array : :Hash

data/lib/rails/graphql/helpers/inherited_collection/hash.rb

@@ -5,6 +5,7 @@ module Rails
       # or sets
       class InheritedCollection::Hash < InheritedCollection::Base
         delegate :transform_values, :transform_keys, to: :to_hash
+        delegate :filter_map, :map, to: :eager
 
         # Simply go over each definition and check for the given key
         def key?(value)
@@ -44,7 +45,7 @@ module Rails
           keys.lazy.map(&method(:[]))
         end
 
-        # Basically allow this lazy operator to be merged with other hashes
+        # Basically returns the plain result value
         def to_hash
           each.to_h
         end

data/lib/rails/graphql/helpers/registerable.rb

@@ -25,7 +25,7 @@ module Rails
           GraphQL.type_map.postpone_registration(subclass)
         end
 
-        # Check if the class is already registered in the typemap
+        # Check if the class is already registered in the type map
         def registered?
           GraphQL.type_map.object_exist?(self, exclusive: true)
         end

data/lib/rails/graphql/helpers/with_arguments.rb

@@ -59,14 +59,15 @@ module Rails
         end
 
         # See {Argument}[rdoc-ref:Rails::GraphQL::Argument] class.
-        def argument(name, base_type, **xargs)
-          object = GraphQL::Argument.new(name, base_type, **xargs, owner: self)
+        def argument(name, type = nil, **xargs)
+          object = GraphQL::Argument.new(name, type, **xargs, owner: self)
 
           raise DuplicatedError, (+<<~MSG).squish if has_argument?(object.name)
             The #{name.inspect} argument is already defined and can't be redefined.
           MSG
 
           arguments[object.name] = object
+          self
         rescue DefinitionError => e
           raise e.class, +"#{e.message}\n  Defined at: #{caller(2)[0]}"
         end

data/lib/rails/graphql/helpers/with_callbacks.rb

@@ -5,11 +5,11 @@ module Rails
     module Helpers
       # Callbacks is an extension of the events which works with the
       # {Callback}[rdoc-ref:Rails::GraphQL::Callback] class, then having extra
-      # powers when actually executing the event against procs or owner-based
-      # symbolic methods
+      # powers when actually executing the event against Procs or owner-based
+      # methods, when provided a symbol
       module WithCallbacks
         DEFAULT_EVENT_TYPES = %i[query mutation subscription request attach
-          authorize organized prepared finalize].freeze
+          authorize organized prepared finalize prepare subscribed].freeze
 
         def self.extended(other)
           other.extend(WithCallbacks::Setup)

data/lib/rails/graphql/helpers/with_description.rb

@@ -12,17 +12,19 @@ module Rails
 
         # Define and format description
         def description=(value)
-          @description = value.to_s.presence&.strip_heredoc&.chomp
+          if !value.nil?
+            @description = value.to_s.presence&.strip_heredoc&.chomp
+          elsif defined?(@description)
+            @description = nil
+          end
         end
 
-        # Return the description of the argument
+        # Return a description, by defined value or I18n
         def description(namespace = nil, kind = nil)
           return @description if description?
           return unless GraphQL.config.enable_i18n_descriptions
 
-          # If it has been defined, but as nil, then it will always be nil
-          return if defined?(@description)
-          @description = i18n_description(namespace, kind)
+          i18n_description(namespace, kind)
         end
 
         # Checks if a description was provided
@@ -34,7 +36,8 @@ module Rails
 
           # Return a description from I18n
           def i18n_description(namespace = nil, kind = nil)
-            return if (parent = try(:owner)).try(:spec_object?)
+            return if (parent = try(:owner)).try(:spec_object?) &&
+              parent.kind != :schema
 
             values = {
               kind: kind || try(:kind),
@@ -49,8 +52,7 @@ module Rails
               next if key.include?('..')
 
               result = catch(:exception) { ::I18n.translate(key, throw: true) }
-              return result unless result.is_a?(Hash) ||
-                result.is_a?(I18n::MissingTranslation)
+              return result if result.is_a?(String)
             end
           end
 

data/lib/rails/graphql/helpers/with_directives.rb

@@ -59,12 +59,14 @@ module Rails
             list << item_or_symbol
           end
 
-          directives += GraphQL.directives_to_set(list, all_directives, source: self)
+          directives.merge(GraphQL.directives_to_set(list, all_directives, source: self))
+          self
         rescue DefinitionError => e
           raise e.class, +"#{e.message}\n  Defined at: #{caller(2)[0]}"
         end
 
         # Check whether a given directive is being used
+        # TODO: This does not work with the instance
         def using?(item)
           directive = (item.is_a?(Symbol) || item.is_a?(String)) ? fetch!(item) : item
           raise ArgumentError, (+<<~MSG).squish unless directive < GraphQL::Directive
@@ -76,6 +78,8 @@ module Rails
 
         alias has_directive? using?
 
+        # TODO: Maybe implement a method to fetch a specific directive
+
         # Override the +all_listeners+ method since callbacks can eventually be
         # attached to objects that have directives, which then they need to
         # be combined

data/lib/rails/graphql/helpers/with_events.rb

@@ -72,6 +72,7 @@ module Rails
 
           listeners << event_name
           events[event_name].send(unshift ? :unshift : :push, callback || block)
+          self
         end
       end
     end

data/lib/rails/graphql/helpers/with_fields.rb

@@ -19,7 +19,7 @@ module Rails
             fields.each_value(&subclass.method(:proxy_field))
           end
 
-          # Return the list of fileds, only initialize when explicitly told
+          # Return the list of fields, only initialize when explicitly told
           def fields(initialize = nil)
             return @fields if defined?(@fields)
             return unless initialize
@@ -51,7 +51,7 @@ module Rails
         def field(name, *args, **xargs, &block)
           object = field_type.new(name, *args, **xargs, owner: self, &block)
 
-          raise DuplicatedError, (+<<~MSG).squish if field?(object.name)
+          raise DuplicatedError, (+<<~MSG).squish if has_field?(object.name)
             The #{name.inspect} field is already defined and can't be redefined.
           MSG
 
@@ -63,13 +63,14 @@ module Rails
         # Add a new field to the list but use a proxy instead of a hard copy of
         # a given +field+
         def proxy_field(field, *args, **xargs, &block)
+          field = field.field if field.is_a?(Module) && field <= Alternative::Query
           raise ArgumentError, (+<<~MSG).squish unless field.is_a?(field_type)
             The #{field.class.name} is not a valid field.
           MSG
 
           xargs[:owner] = self
           object = field.to_proxy(*args, **xargs, &block)
-          raise DuplicatedError, (+<<~MSG).squish if field?(object.name)
+          raise DuplicatedError, (+<<~MSG).squish if has_field?(object.name)
             The #{field.name.inspect} field is already defined and can't be replaced.
           MSG
 
@@ -99,8 +100,8 @@ module Rails
           list.flatten.map { |item| self[item]&.enable! }
         end
 
-        # Check wheter a given field +object+ is defined in the list of fields
-        def field?(object)
+        # Check whether a given field +object+ is defined in the list of fields
+        def has_field?(object)
           return false unless fields?
           object = object.name if object.is_a?(GraphQL::Field)
           fields.key?(object.is_a?(String) ? object.underscore.to_sym : object)
@@ -122,7 +123,7 @@ module Rails
           MSG
         end
 
-        # Get the list of GraphQL names of all the fields difined
+        # Get the list of GraphQL names of all the fields defined
         def field_names(enabled_only = true)
           (enabled_only ? enabled_fields : lazy_each_field)&.map(&:gql_name)&.eager
         end
@@ -133,32 +134,35 @@ module Rails
         end
 
         # Import one or more field into the current list of fields
-        def import(klass, ignore_abstract: false)
-          return if ignore_abstract && klass.try(:abstract?)
+        def import(source)
+          # Import an alternative declaration of a field
+          if source.is_a?(Module) && source <= Alternative::Query
+            return proxy_field(type, source.field)
+          end
 
-          if klass.is_a?(Module) && klass <= Alternative::Query
-            # Import an alternative declaration of a field
-            proxy_field(klass.field)
-          elsif klass.is_a?(Helpers::WithFields)
+          case source
+          when Array
+            # Import a list of fields
+            source.each { |field| proxy_field(type, field) }
+          when Hash, Concurrent::Map
+            # Import a keyed list of fields
+            source.each_value { |field| proxy_field(type, field) }
+          when Helpers::WithFields
             # Import a set of fields
-            klass.fields.each_value { |field| proxy_field(field) }
+            source.fields.each_value { |field| proxy_field(type, field) }
           else
             return if GraphQL.config.silence_import_warnings
-            GraphQL.logger.warn(+"Unable to import #{klass.inspect} into #{self.name}.")
+            GraphQL.logger.warn(+"Unable to import #{source.inspect} into #{self.name}.")
           end
         end
 
         # Import a module containing several classes to be imported
-        def import_all(mod, recursive: false, ignore_abstract: false)
+        def import_all(mod, recursive: false, **xargs)
           mod.constants.each do |const_name|
             object = mod.const_get(const_name)
 
-            if object.is_a?(Class)
-              import(object, ignore_abstract: ignore_abstract)
-            elsif object.is_a?(Module) && recursive
-              # TODO: Maybe add deepness into the recursive value
-              import_all(object, recursive: recursive, ignore_abstract: ignore_abstract)
-            end
+            import(object, **xargs) if object.is_a?(Class)
+            import_all(object, recursive: recursive, **xargs) if recursive && object.is_a?(Module)
           end
         end
 
@@ -179,11 +183,13 @@ module Rails
         protected
 
           # A little helper to define arguments using the :arguments key
-          def arg(*args, **xargs, &block)
+          def argument(*args, **xargs, &block)
             xargs[:owner] = self
             GraphQL::Argument.new(*args, **xargs, &block)
           end
 
+          alias arg argument
+
         private
 
           def lazy_each_field

data/lib/rails/graphql/helpers/with_name.rb

@@ -7,7 +7,7 @@ module Rails
     module Helpers
       # Helper module responsible for name stuff
       module WithName
-        NAME_EXP = /GraphQL::(?:Type::\w+::|Directive::)?([:\w]+?)([A-Z][a-z]+)?\z/.freeze
+        NAME_EXP = /GraphQL::(?:Type::\w+::|Directive::)?([:\w]+)\z/.freeze
 
         # Here we define a couple of attributes used by registration
         def self.extended(other)
@@ -20,7 +20,8 @@ module Rails
         # Return the name of the object as a GraphQL name
         def gql_name
           @gql_name ||= begin
-            name.match(NAME_EXP).try(:[], 1)&.tr(':', '')
+            result = name.match(NAME_EXP).try(:[], 1)
+            result.tr(':', '').chomp(base_type.name.demodulize) unless result.nil?
           end unless anonymous?
         end