rails-graphql 0.2.1 → 1.0.0.beta

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,23 @@ 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)
         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 fileds, 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,31 @@ 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 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)
+          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 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
@@ -90,33 +101,65 @@ module Rails # :nodoc:
 
         # Check wheter a given field +object+ is defined in the list of fields
         def 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
         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(klass, ignore_abstract: false)
+          return if ignore_abstract && klass.try(:abstract?)
+
+          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)
+            # Import a set of fields
+            klass.fields.each_value { |field| proxy_field(field) }
+          else
+            return if GraphQL.config.silence_import_warnings
+            GraphQL.logger.warn(+"Unable to import #{klass.inspect} into #{self.name}.")
+          end
+        end
+
+        # Import a module containing several classes to be imported
+        def import_all(mod, recursive: false, ignore_abstract: false)
+          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
+          end
         end
 
         # Validate all the fields to make sure the definition is valid
@@ -125,7 +168,12 @@ 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
@@ -135,6 +183,12 @@ module Rails # :nodoc:
             xargs[:owner] = self
             GraphQL::Argument.new(*args, **xargs, &block)
           end
+
+        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,43 @@
+# 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]+?)([A-Z][a-z]+)?\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
+            name.match(NAME_EXP).try(:[], 1)&.tr(':', '')
+          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)