rails-graphql 0.2.1 → 1.0.0.rc1

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    module Helpers
+      module WithDescription
+
+        # A getter or setter in the same function
+        def desc(value = nil)
+          value.nil? ? description : (self.description = value)
+        end
+
+        # Define and format description
+        def description=(value)
+          if !value.nil?
+            @description = value.to_s.presence&.strip_heredoc&.chomp
+          elsif defined?(@description)
+            @description = nil
+          end
+        end
+
+        # 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
+
+          i18n_description(namespace, kind)
+        end
+
+        # Checks if a description was provided
+        def description?
+          defined?(@description) && !!@description
+        end
+
+        protected
+
+          # Return a description from I18n
+          def i18n_description(namespace = nil, kind = nil)
+            return if (parent = try(:owner)).try(:spec_object?) &&
+              parent.kind != :schema
+
+            values = {
+              kind: kind || try(:kind),
+              parent: i18n_parent_value(parent),
+              namespace: GraphQL.enumerate(namespace || try(:namespaces)).first,
+              name: is_a?(Module) ? to_sym : name,
+            }
+
+            options = GraphQL.config.i18n_scopes.dup
+            while option = options.shift
+              key = format(option, values)
+              next if key.include?('..')
+
+              result = catch(:exception) { ::I18n.translate(key, throw: true) }
+              return result if result.is_a?(String)
+            end
+          end
+
+          # Properly figure out the parent value for the interpolation
+          def i18n_parent_value(parent)
+            if parent.respond_to?(:i18n_scope)
+              parent.i18n_scope(self)
+            elsif parent.is_a?(Helpers::WithSchemaFields) && respond_to?(:schema_type)
+              schema_type
+            else
+              parent.try(:to_sym)
+            end
+          end
+
+      end
+    end
+  end
+end

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Helpers # :nodoc:
+module Rails
+  module GraphQL
+    module Helpers
       # Helper module that allows other objects to hold directives during the
       # definition process
       module WithDirectives
@@ -15,12 +15,14 @@ module Rails # :nodoc:
         def self.included(other)
           other.extend(WithDirectives::DirectiveLocation)
           other.define_method(:directives) { @directives ||= Set.new }
-          other.class_attribute(:directive_location, instance_writer: false)
+          other.define_method(:all_directives) { @directives if defined?(@directives) }
+          other.define_method(:directives?) { defined?(@directives) && @directives.present? }
         end
 
         def initialize_copy(orig)
           super
 
+          return if orig.directives.nil?
           @directives = orig.directives.dup
         end
 
@@ -35,25 +37,20 @@ module Rails # :nodoc:
 
           # Use this once to define the directive location
           def directive_location=(value)
-            raise ArgumentError, 'Directive location is already defined' \
+            raise ArgumentError, +'Directive location is already defined' \
               unless directive_location.nil?
 
             @directive_location = value
           end
         end
 
-        # Mostly for correct inheritance on instances
-        def all_directives
-          defined?(@directives) ? @directives : Set.new
-        end
-
         # Use this method to assign directives to the given definition. You can
         # also provide a symbol as a first argument and extra named-arguments
         # to auto initialize a new instance of that directive.
         def use(item_or_symbol, *list, **xargs)
           if item_or_symbol.is_a?(Symbol)
             directive = fetch!(item_or_symbol)
-            raise ArgumentError, <<~MSG.squish unless directive < GraphQL::Directive
+            raise ArgumentError, (+<<~MSG).squish unless directive < GraphQL::Directive
               Unable to find the #{item_or_symbol.inspect} directive.
             MSG
 
@@ -62,45 +59,69 @@ module Rails # :nodoc:
             list << item_or_symbol
           end
 
-          current = try(:all_directives) || @directives
-          items = GraphQL.directives_to_set(list, current, source: self)
-          directives.merge(items)
+          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]}"
+          raise e.class, +"#{e.message}\n  Defined at: #{caller(2)[0]}"
         end
 
-        # Check wheter a given directive is being used
-        def using?(item_or_symbol)
-          directive = item_or_symbol.is_a?(Symbol) ? fetch!(item_or_symbol) : item_or_symbol
-          raise ArgumentError, <<~MSG.squish unless directive < GraphQL::Directive
-            The provided #{item_or_symbol.inspect} is not a valid directive.
+        # 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
+            The provided #{item.inspect} is not a valid directive.
           MSG
 
-          all_directives.any? { |item| item.is_a?(directive) }
+          !!all_directives&.any?(directive)
         end
 
         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
-        def all_listeners
-          current = all_directives.map(&:all_listeners).reduce(:+) || Set.new
-          (defined?(super) ? super : Set.new) + current
+        def all_directive_listeners
+          inherited = super if defined?(super)
+          return inherited unless directives?
+
+          current = all_directives.map(&:all_listeners).compact.reduce(:+)
+          inherited.nil? ? current : inherited + current
         end
 
+        alias all_listeners all_directive_listeners
+
+        # Make sure to consider directive listeners while checking for listeners
+        def directive_listeners?
+          (defined?(super) && super) || all_directives&.any?(&:listeners?)
+        end
+
+        alias listeners? directive_listeners?
+
         # Override the +all_events+ method since callbacks can eventually be
         # attached to objects that have directives, which then they need to
         # be combined
-        def all_events
-          Helpers::AttributeDelegator.new do
-            base = defined?(super) ? super : {}
-            all_directives.map(&:all_events).inject(base) do |lhash, rhash|
-              Helpers.merge_hash_array(lhash, rhash)
-            end
+        def all_directive_events
+          inherited = super if defined?(super)
+          return inherited unless directives?
+
+          all_directives.inject(inherited || {}) do |result, directive|
+            next result if (val = directive.all_events).blank?
+            Helpers.merge_hash_array(result, val)
           end
         end
 
+        alias all_events all_directive_events
+
+        # Make sure to consider directive events while checking for events
+        def directive_events?
+          (defined?(super) && super) || all_directives&.any?(&:events?)
+        end
+
+        alias events? directive_events?
+
         # Validate all the directives to make sure the definition is valid
         def validate!(*)
           super if defined? super
@@ -110,6 +131,13 @@ module Rails # :nodoc:
           @directives.freeze
         end
 
+        protected
+
+          # Helper method to inspect the directives
+          def inspect_directives
+            all_directives&.map(&:inspect)&.join(' ')
+          end
+
         private
 
           # Find a directive for its symbolized name

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Helpers # :nodoc:
+module Rails
+  module GraphQL
+    module Helpers
       # Helper module that allows other objects to hold events, either from a
       # singleton point-of-view, or for instances
       module WithEvents
@@ -19,7 +19,12 @@ module Rails # :nodoc:
           other.delegate(:event_types, to: :class)
 
           other.define_method(:events) { @events ||= Hash.new { |h, k| h[k] = [] } }
+          other.define_method(:all_events) { @events if defined?(@events) }
+          other.define_method(:events?) { defined?(@events) && @events.present? }
+
           other.define_method(:listeners) { @listeners ||= Set.new }
+          other.define_method(:all_listeners) { @listeners if defined?(@listeners) }
+          other.define_method(:listeners?) { defined?(@listeners) && @listeners.present? }
         end
 
         # Helper module to define static list of valid event types
@@ -27,10 +32,11 @@ module Rails # :nodoc:
           # Set or get the list of possible event types when attaching events
           def event_types(*list, append: false, expose: false)
             return (defined?(@event_types) && @event_types.presence) ||
-              superclass.try(:event_types) || [] if list.blank?
+              superclass.try(:event_types) || EMPTY_ARRAY if list.blank?
+
+            new_list = list.flatten.compact.map(&:to_sym)
+            new_list = event_types + new_list if append
 
-            new_list = append ? event_types : []
-            new_list += list.flatten.compact.map(&:to_sym)
             @event_types = new_list.uniq.freeze
             expose_events!(*list) if expose
             @event_types
@@ -38,7 +44,7 @@ module Rails # :nodoc:
 
           protected
 
-            # Auxiliar method that creates easy-accessible callback assignment
+            # Auxiliary method that creates easy-accessible callback assignment
             def expose_events!(*list)
               list.each do |event_name|
                 next if method_defined?(event_name)
@@ -49,31 +55,24 @@ module Rails # :nodoc:
             end
         end
 
-        # Mostly for correct inheritance on instances
-        def all_events
-          current = defined?(@events) ? @events : {}
-          return current unless defined? super
-          Helpers.merge_hash_array(current, super)
-        end
-
-        # Mostly for correct inheritance on instances
-        def all_listeners
-          current = (defined?(@listeners) && @listeners) || Set.new
-          defined?(super) ? (current + super) : current
-        end
-
         # Add a new event listener for the given +event_name+. It is possible
         # to prepend the event by setting +unshift: true+. This checks if the
         # event name is a valid one due to +event_types+.
-        def on(event_name, unshift: false, &block)
+        def on(event_name, callback = nil, unshift: false, &block)
           event_name = event_name.to_sym
           valid = !event_types || event_types.include?(event_name)
-          raise ArgumentError, <<~MSG.squish unless valid
+          raise ArgumentError, (+<<~MSG).squish unless valid
             The #{event_name} is not a valid event type.
           MSG
 
+          invalid_callback = callback.nil? || callback.is_a?(Callback)
+          raise ArgumentError, (+<<~MSG).squish unless invalid_callback
+            The provided #{callback.class.name} is not a valid callback.
+          MSG
+
           listeners << event_name
-          events[event_name].send(unshift ? :unshift : :push, block)
+          events[event_name].send(unshift ? :unshift : :push, callback || block)
+          self
         end
       end
     end

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Helpers # :nodoc:
+module Rails
+  module GraphQL
+    module Helpers
       # Helper module that allows other objects to hold fields during the
       # definition process. Works very similar to Arguments, but it's more
       # flexible, since the type of the fields can be dynamic defined by the
@@ -12,19 +12,31 @@ module Rails # :nodoc:
       # related to the base type, but it's closer associated with the strategy
       # used to handle them.
       module WithFields
-        module ClassMethods # :nodoc: all
+        module ClassMethods
           def inherited(subclass)
             super if defined? super
             return unless defined?(@fields)
             fields.each_value(&subclass.method(:proxy_field))
           end
+
+          # Return the list of fields, only initialize when explicitly told
+          def fields(initialize = nil)
+            return @fields if defined?(@fields)
+            return unless initialize
+
+            @fields = Concurrent::Map.new
+          end
+
+          # Check if there are any fields defined
+          def fields?
+            defined?(@fields) && @fields.present?
+          end
         end
 
-        def self.extended(other) # :nodoc:
+        def self.extended(other)
           other.extend(WithFields::ClassMethods)
-          other.define_singleton_method(:fields) { @fields ||= Concurrent::Map.new }
-          other.class_attribute(:field_type, instance_writer: false)
-          other.class_attribute(:valid_field_types, instance_writer: false, default: [])
+          other.class_attribute(:field_type, instance_accessor: false)
+          other.class_attribute(:valid_field_types, instance_accessor: false, default: [])
         end
 
         # Check if the field is already defined before actually creating it
@@ -37,32 +49,32 @@ module Rails # :nodoc:
 
         # See {Field}[rdoc-ref:Rails::GraphQL::Field] class.
         def field(name, *args, **xargs, &block)
-          xargs[:owner] = self
-          object = field_type.new(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
 
-          fields[object.name] = object
+          fields(true)[object.name] = object
         rescue DefinitionError => e
-          raise e.class, e.message + "\n  Defined at: #{caller(2)[0]}"
+          raise e.class, +"#{e.message}\n  Defined at: #{caller(2)[0]}"
         end
 
         # 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)
-          raise ArgumentError, <<~MSG.squish unless field.is_a?(GraphQL::Field)
+          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
 
-          fields[object.name] = object
+          fields(true)[object.name] = object
         end
 
         # Overwrite attributes of a given field named as +name+, it also allows
@@ -88,35 +100,70 @@ module Rails # :nodoc:
           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)
         end
 
         # Allow accessing fields using the hash notation
-        def [](object)
+        def find_field(object)
+          return unless fields?
           object = object.name if object.is_a?(GraphQL::Field)
           fields[object.is_a?(String) ? object.underscore.to_sym : object]
         end
 
-        alias find_field []
+        alias [] find_field
 
         # If the field is not found it will raise an exception
         def find_field!(object)
-          find_field(object) || raise(::ArgumentError, <<~MSG.squish)
+          find_field(object) || raise(NotFoundError, (+<<~MSG).squish)
             The #{object.inspect} field is not defined yet.
           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 : fields.each_value).map(&:gql_name).compact
+          (enabled_only ? enabled_fields : lazy_each_field)&.map(&:gql_name)&.eager
         end
 
         # Return a lazy enumerator for enabled fields
         def enabled_fields
-          fields.values.select(&:enabled?)
+          lazy_each_field&.select(&:enabled?)
+        end
+
+        # Import one or more field into the current list of fields
+        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
+
+          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
+            source.fields.each_value { |field| proxy_field(type, field) }
+          else
+            return if GraphQL.config.silence_import_warnings
+            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, **xargs)
+          mod.constants.each do |const_name|
+            object = mod.const_get(const_name)
+
+            import(object, **xargs) if object.is_a?(Class)
+            import_all(object, recursive: recursive, **xargs) if recursive && object.is_a?(Module)
+          end
         end
 
         # Validate all the fields to make sure the definition is valid
@@ -125,16 +172,29 @@ module Rails # :nodoc:
 
           # TODO: Maybe find a way to freeze the fields, since after validation
           # the best thing to do is block changes
-          fields.each_value(&:validate!)
+          fields&.each_value(&:validate!)
+        end
+
+        # Find a specific field using its id as +gql_name.type+
+        def find_by_gid(gid)
+          find_field!(gid.name)
         end
 
         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
+            fields.each_pair.lazy.each_entry.map(&:last) if fields?
+          end
       end
     end
   end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    module Helpers
+      # Helper module that is a different implementation of the
+      # +GlobalID::Identification+, but instead of things being found by the
+      # class that they are, it uses owners and base classes.
+      module WithGlobalID
+        def to_global_id(options = nil)  # :nodoc:
+          GlobalID.create(self, options)
+        end
+
+        alias to_gid to_global_id
+
+        def to_gid_param(options = nil)  # :nodoc:
+          to_global_id(options).to_param
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/anonymous'
+
+module Rails
+  module GraphQL
+    module Helpers
+      # Helper module responsible for name stuff
+      module WithName
+        NAME_EXP = /GraphQL::(?:Type::\w+::|Directive::)?([:\w]+)\z/.freeze
+
+        # Here we define a couple of attributes used by registration
+        def self.extended(other)
+          # TODO: Move to registerable
+          # An abstract type won't appear in the introspection and will not be
+          # instantiated by requests
+          other.class_attribute :abstract, instance_accessor: false, default: false
+        end
+
+        # Return the name of the object as a GraphQL name
+        def gql_name
+          @gql_name ||= begin
+            result = name.match(NAME_EXP).try(:[], 1)
+            result.tr(':', '').chomp(base_type.name.demodulize) unless result.nil?
+          end unless anonymous?
+        end
+
+        alias graphql_name gql_name
+
+        # Return the name of the object as a symbol
+        def to_sym
+          @gql_key ||= gql_name&.underscore&.to_sym
+        end
+
+        protected
+
+          # Change the gql name of the object
+          def rename!(name)
+            @gql_name = name.to_s
+          end
+      end
+    end
+  end
+end

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Helpers # :nodoc:
+module Rails
+  module GraphQL
+    module Helpers
       # Helper module that allows other objects to hold namespaces. It can
       # either work as an extension of the superclass using +add_namespace+ or
       # it can be reset then set using +namespace+.
@@ -10,7 +10,10 @@ module Rails # :nodoc:
         # Returns the list of defined namespaces
         def namespaces
           return @namespaces if defined?(@namespaces)
-          superclass.try(:namespaces) || Set.new
+          superclass.try(:namespaces) || begin
+            value = GraphQL.type_map.associated_namespace_of(self)
+            @namespaces = value unless value.nil?
+          end
         end
 
         # Set or overwrite the list of namespaces

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

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Helpers # :nodoc:
-      # Helper module that allows other objects to hold an +assigned_to+ object
+module Rails
+  module GraphQL
+    module Helpers
+      # Helper focus on event execution when objects have a owner property,
+      # pratically allowing resolvers and similar to be called in the owner
       module WithOwner
         def self.included(other)
           other.extend(WithOwner::ClassMethods)
           other.class_attribute(:owner, instance_writer: false)
         end
 
-        module ClassMethods # :nodoc: all
+        module ClassMethods
           def method_defined?(method_name)
             super || owner&.method_defined?(method_name)
           end
@@ -18,11 +19,11 @@ module Rails # :nodoc:
 
         private
 
-          def respond_to_missing?(*args) # :nodoc:
+          def respond_to_missing?(*args)
             owner_respond_to?(*args) || super
           end
 
-          def method_missing(method_name, *args, **xargs, &block) # :nodoc:
+          def method_missing(method_name, *args, **xargs, &block)
             return super unless owner_respond_to?(method_name)
             event.on_instance(owner) do |obj|
               obj.public_send(method_name, *args, **xargs, &block)