rails-graphql 0.1.0

data/lib/rails/graphql/helpers.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Helpers # :nodoc:
+      extend ActiveSupport::Autoload
+
+      autoload :AttributeDelegator
+      autoload :InheritedCollection
+      autoload :LeafFromAr
+      autoload :Registerable
+
+      autoload :WithArguments
+      autoload :WithAssignment
+      autoload :WithCallbacks
+      autoload :WithDirectives
+      autoload :WithEvents
+      autoload :WithFields
+      autoload :WithNamespace
+      autoload :WithOwner
+      autoload :WithSchemaFields
+      autoload :WithValidator
+
+      # Easy way to duplicate objects and set a new owner
+      def self.dup_all_with_owner(enumerator, owner)
+        enumerator.map { |item| dup_with_owner(item, owner) }.presence
+      end
+
+      # Easy way to duplicate a object and set a new owner
+      def self.dup_with_owner(item, owner)
+        item.dup.tap { |x| x.instance_variable_set(:@owner, owner) }
+      end
+
+      # Global helper that merge a hash that contains values as arrays
+      def self.merge_hash_array(one, other)
+        one.merge(other) { |_, lval, rval| lval + rval }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Helpers # :nodoc:
+      # This is an extra magic on top of the delegator class from the standard
+      # lib that allows fetching a specific property of the delegated object
+      class AttributeDelegator < ActiveSupport::ProxyObject
+        def initialize(obj = nil, attribute = nil, cache: true, &block)
+          @delegate_sd_attr = attribute
+          @delegate_sd_obj = block.presence || obj
+          @delegate_cache = cache
+        end
+
+        private
+
+          def respond_to_missing?(method_name, include_private = false) # :nodoc:
+            __getobj__.respond_to?(method_name, include_private) || super
+          end
+
+          def method_missing(method_name, *args, **xargs, &block) # :nodoc:
+            return super unless __getobj__.respond_to?(method_name)
+            __getobj__.public_send(method_name, *args, **xargs, &block)
+          end
+
+          def __getobj__
+            @delegate_cache ? (@delegate_ch_obj ||= __buildobj__) : __buildobj__
+          end
+
+          def __buildobj__
+            result = @delegate_sd_obj
+            result = result.call if result.respond_to?(:call)
+            result = result&.public_send(@delegate_sd_attr) if @delegate_sd_attr
+            result
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Helpers # :nodoc:
+      module InheritedCollection # :nodoc:
+        DEFAULT_TYPES = {
+          array:      '[]',
+          set:        'Set.new',
+          hash:       '{}',
+          hash_array: 'Hash.new { |h, k| h[k] = [] }',
+          hash_set:   'Hash.new { |h, k| h[k] = Set.new }',
+        }.freeze
+
+        # Declare a class-level attribute whose value is both isolated and also
+        # inherited from parent classes. Subclasses can change their own value
+        # and it will not impact parent class.
+        #
+        # Inspired by +class_attribute+ from ActiveSupport.
+        #
+        # ==== Options
+        #
+        # * <tt>:instance_reader</tt> - Sets the instance reader method (defaults to true).
+        # * <tt>:instance_predicate</tt> - Sets a predicate method (defaults to true).
+        # * <tt>:type</tt> - Defines the type of the values stored (defaults to :set).
+        #
+        # ==== Examples
+        #
+        #   class Base
+        #     inherited_collection :settings
+        #   end
+        #
+        #   class Subclass < Base
+        #   end
+        #
+        #   Base.settings << :a
+        #   Subclass.settings            # => []
+        #   Subclass.all_settings        # => [:a]
+        #   Subclass.settings << :b
+        #   Subclass.settings            # => [:b]
+        #   Subclass.all_settings        # => [:a, :b]
+        #   Base.settings                # => [:a]
+        #   Base.all_settings            # => [:a]
+        #
+        # For convenience, an instance predicate method is defined as well,
+        # which checks for the +all_+ method. To skip it, pass
+        # <tt>instance_predicate: false</tt>.
+        #
+        #   Subclass.settings?       # => false
+        #
+        # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
+        #
+        #   object.settings          # => NoMethodError
+        #   object.settings?         # => NoMethodError
+        #
+        def inherited_collection(
+          *attrs,
+          instance_reader: true,
+          instance_predicate: true,
+          type: :set
+        )
+          attrs.each do |name|
+            module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+              def self.all_#{name}
+                ::Rails::GraphQL::Helpers::AttributeDelegator.new do
+                  fetch_inherited_#{type}('@#{name}')
+                end
+              end
+
+              def self.#{name}
+                @#{name} ||= #{DEFAULT_TYPES[type]}
+              end
+            RUBY
+
+            module_eval(<<~RUBY, __FILE__, __LINE__ + 1) if instance_predicate
+              def self.#{name}?
+                (defined?(@#{name}) && @#{name}.present?) || superclass.try(:#{name}?)
+              end
+            RUBY
+
+            if instance_reader
+              delegate(name.to_sym, :"all_#{name}", to: :class)
+              delegate(:"#{name}?", to: :class) if instance_predicate
+            end
+          end
+        end
+
+        protected
+
+          # Combine an inherited list of arrays
+          def fetch_inherited_array(ivar)
+            inherited_ancestors.each_with_object([]) do |klass, result|
+              next result unless klass.instance_variable_defined?(ivar)
+              val = klass.instance_variable_get(ivar)
+              result.merge(val) unless val.blank?
+            end
+          end
+
+          # Combine an inherited list of set objects
+          def fetch_inherited_set(ivar)
+            inherited_ancestors.each_with_object(Set.new) do |klass, result|
+              next result unless klass.instance_variable_defined?(ivar)
+              val = klass.instance_variable_get(ivar)
+              result.merge(val) unless val.blank?
+            end
+          end
+
+          # Combine an inherited list of hashes but keeping only the most recent
+          # value, which means that keys might be replaced
+          def fetch_inherited_hash(ivar)
+            inherited_ancestors.each_with_object({}) do |klass, result|
+              next result unless klass.instance_variable_defined?(ivar)
+              val = klass.instance_variable_get(ivar)
+              result.merge!(val) unless val.blank?
+            end
+          end
+
+          # Right now we can't use Hash with default proc for equivalency due to
+          # a bug on Ruby https://bugs.ruby-lang.org/issues/17181
+
+          # Combine an inherited list of hashes, which also will combine arrays,
+          # ensuring that same key items will be combined
+          def fetch_inherited_hash_array(ivar)
+            inherited_ancestors.inject({}) do |result, klass|
+              next result unless klass.instance_variable_defined?(ivar)
+              val = klass.instance_variable_get(ivar)
+              Helpers.merge_hash_array(result, val)
+            end
+          end
+
+          # Combine an inherited list of hashes, which also will combine arrays,
+          # ensuring that same key items will be combined
+          def fetch_inherited_hash_set(ivar)
+            inherited_ancestors.inject({}) do |result, klass|
+              next result unless klass.instance_variable_defined?(ivar)
+              val = klass.instance_variable_get(ivar)
+              Helpers.merge_hash_array(result, val)
+            end
+          end
+
+        private
+
+          # Return a list of all the ancestor classes up until object
+          def inherited_ancestors
+            [self].tap do |list|
+              list.unshift(list.first.superclass) until list.first.superclass === Object
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Helpers # :nodoc:
+      # Helper module allowing leaf values to be collected direct from
+      # ActiveRecord. It also helps AR Adapters to define the necessary
+      # methods and settings to operate with this extractor.
+      #
+      # TODO: Implement ActiveRecord serialization
+      module LeafFromAr
+        def self.extended(other)
+          # Defines which type exactly represents the scalar type on the
+          # ActiveRecord adapter for casting purposes
+          other.class_attribute :ar_adapter_type, instance_writer: false, default: {}
+
+          # A list of ActiveRecord aliases per adapter to skip casting
+          other.class_attribute :ar_adapter_aliases, instance_writer: false,
+            default: (Hash.new { |h, k| h[k] = Set.new })
+        end
+
+        # Identifies the ActiveRecord type (actually it uses the
+        # ActiveModel::Type#type method, but ActiveRecord uses the same
+        # reference) of this object. When mismatching, the query must cast the
+        # value.
+        def ar_type
+          :string
+        end
+
+        # If a class extend this module, we assume that it can serialize
+        # attributes direct from the query point of view
+        def from_ar?(ar_object, attribute)
+          ar_object&.has_attribute?(attribute)
+        end
+
+        # Returns an Arel object that represents how this object is serialized
+        # direct from the query
+        #
+        # This happens in 3 parts
+        #
+        # 1. It finds a method to get the arel representation of the
+        #    accessor of the given attribute
+        # 2. If the attribute type mismatch the ar type or any of its aliases,
+        #    then invoke a adapter-specific cast
+        # 3. If necessary, adapters can describe a specific way to serialize
+        #    the arel attribute to ensure equivalency
+        #
+        # ==== Example
+        #
+        # Lets imagine a scenario where the adapter is the +PostgreSQL+, the
+        # attribute is a +data+ field with +enum+ type from a +sample+ table and
+        # the result must be a binary base64 data:
+        #
+        # 1. Sample.arel_attribute(:data)
+        #    # => "samples"."data"
+        # 2. Arel::Nodes::NamedFunction.new('CAST', [arel_object, Arel.sql('text')])
+        #    # => CAST("samples"."data" AS text)
+        # 3. Arel::Nodes::NamedFunction.new('ENCODE', [arel_object, Arel.sql("'base64")])
+        #    # => ENCODE(CAST("samples"."data" AS text), 'base64')
+        def from_ar(ar_object, attribute)
+          key = adapter_key(ar_object)
+          method_name = "from_#{key}_adapter"
+          method_name = 'from_abstract_adapter' unless respond_to?(method_name, true)
+
+          arel_object = send(method_name, ar_object, attribute)
+          return if arel_object.nil?
+
+          arel_object = try("cast_#{key}_attribute", arel_object, ar_adapter_type[key]) \
+            unless match_ar_type?(ar_object, attribute, key)
+          return if arel_object.nil?
+
+          method_name = "#{key}_serialize"
+          respond_to?(method_name, true) ? try(method_name, arel_object) : arel_object
+        end
+
+        # Helper method that should be used for ActiveRecord adapters in order
+        # to provide the correct methods and settings for retrieving the given
+        # value direct from a query.
+        #
+        # ==== Options
+        #
+        # * <tt>:fetch</tt> - A specific function to build the arel for fetching the attribute
+        # * <tt>:cast</tt> - A function to cast an attribute to the correct value
+        # * <tt>:type</tt> - A symbol that represents the exactly database type that matches
+        #   the ActiveRecord type (ie. :varchar for :string)
+        # * <tt>:aliases</tt> - An array of AR aliases that for the adapter they are
+        #   equivalent
+        def define_for(adapter, **settings)
+          adapter = ar_adapters[adapter] if ar_adapters.key?(adapter)
+          raise ArgumentError, <<~MSG.squish unless ar_adapters.values.include?(adapter)
+            The given #{adapter.inspect} adapter is not a valid option.
+            The valid options are: #{ar_adapters.to_a.flatten.map(&:inspect).to_sentence}.
+          MSG
+
+          define_singleton_method("from_#{adapter}_adapter", &settings[:fetch]) \
+            if settings.key?(:fetch)
+
+          define_singleton_method("cast_#{adapter}_attribute", &settings[:cast]) \
+            if settings.key?(:cast)
+
+          ar_adapter_type[adapter] = settings[:type] if settings.key?(:type)
+          ar_adapter_aliases[adapter] += Array.wrap(settings[:aliases]) \
+            if settings.key?(:aliases)
+        end
+
+        protected
+
+          # A pretty abstract way to access an attribute from an ActiveRecord
+          # object using arel
+          def from_abstract_adapter(ar_object, attribute)
+            ar_object.arel_attribute(attribute)
+          end
+
+          # Change the ActiveRecord type of the given object
+          def set_ar_type!(type)
+            redefine_singleton_method(:ar_type) { type }
+          end
+
+        private
+
+          # Return the list of defined ActiveRecord Adapters
+          def ar_adapters
+            GraphQL.config.ar_adapters
+          end
+
+          # Given the ActiveRecord Object, find the key to compound the method
+          # name for the specific attribute accessor
+          def adapter_key(ar_object)
+            ar_adapters[ar_object.connection.adapter_name]
+          end
+
+          # Check if the GraphQL ar type of this object matches the
+          # ActiveRecord type or any alias for the specific adapter
+          def match_ar_type?(ar_object, attribute, adapter_key)
+            attr_type = ar_object.columns_hash[attribute.to_s].type
+            ar_type.eql?(attr_type) || ar_adapter_aliases[adapter_key].include?(attr_type)
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Helpers # :nodoc:
+      # Helper module responsible for name stuff and also responsible for
+      # registering the objects to the type map, which also checks for the
+      # uniqueness of the name of things.
+      module Registerable
+        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)
+          other.extend(Registerable::ClassMethods)
+          other.extend(Helpers::WithNamespace)
+
+          # If a type is marked as abstract, it's then used as a base and it
+          # won't appear in the introspection
+          other.class_attribute :abstract, instance_writer: false, default: false
+
+          # Marks if the object is one of those defined on the spec, which
+          # marks the object as part of the introspection system
+          other.class_attribute :spec_object, instance_writer: false, default: false
+
+          # The given description of the type
+          other.class_attribute :description, instance_writer: false
+        end
+
+        module ClassMethods # :nodoc: all
+          # Here we wait for the class to be fully loaded so that we can
+          # correctly trigger the registration
+          def inherited(subclass)
+            super if defined? super
+            return if subclass.try(:abstract)
+            GraphQL.type_map.postpone_registration(subclass)
+          end
+
+          # Check if the class is already registered in the typemap
+          def registered?
+            GraphQL.type_map.object_exist?(self, exclusive: true)
+          end
+
+          # The process to register a class and it's name on the index
+          def register!
+            return if abstract? || gql_name.blank?
+
+            raise DuplicatedError, <<~MSG.squish if registered?
+              The "#{gql_name}" is already defined, the only way to change its
+              definition is by using extensions.
+            MSG
+
+            invalid_internal = !spec_object && gql_name.start_with?('__')
+            raise NameError, <<~MSG.squish if invalid_internal
+              The name "#{gql_name}" is invalid. Only internal objects from the
+              spec can have a name starting with "__".
+            MSG
+
+            super if defined? super
+            GraphQL.type_map.register(self).method(:validate!)
+          end
+        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
+
+        # Get or set a list of aliases for this object
+        def aliases(*list)
+          if list.empty?
+            defined?(@aliases) ? @aliases : Set.new
+          else
+            (@aliases ||= Set.new).merge list.flatten.map do |item|
+              item.to_s.underscore.to_sym
+            end
+          end
+        end
+
+        protected
+
+          # An alias for +description = value.strip_heredoc.chomp+ that can be
+          # used as method
+          def desc(value)
+            self.description = value.strip_heredoc.chomp
+          end
+
+          # Change the gql name of the object
+          def rename!(name)
+            @gql_name = name
+          end
+      end
+    end
+  end
+end