rails-graphql 0.2.0 → 1.0.0.beta

data/lib/rails/graphql/field.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = GraphQL Field
     #
     # A field has multiple purposes, which is defined by the specific subclass
@@ -20,8 +20,6 @@ module Rails # :nodoc:
     #   (defaults to true).
     # * <tt>:full</tt> - Shortcut for +null: false, nullable: false, array: true+
     #   (defaults to false).
-    # * <tt>:method_name</tt> - The name of the method used to fetch the field data
-    #   (defaults to nil).
     # * <tt>:enabled</tt> - Mark the field as enabled
     #   (defaults to true).
     # * <tt>:disabled</tt> - Works as the oposite of the enabled option
@@ -35,6 +33,7 @@ module Rails # :nodoc:
     class Field
       extend ActiveSupport::Autoload
       include Helpers::WithDirectives
+      include Helpers::WithDescription
 
       autoload :ScopedConfig
 
@@ -46,19 +45,25 @@ module Rails # :nodoc:
       autoload :InputField
       autoload :OutputField
       autoload :MutationField
+      autoload :SubscriptionField
 
       attr_reader :name, :gql_name, :owner
 
-      delegate :input_type?, :output_type?, :leaf_type?, :proxy?, :mutation?, to: :class
+      alias gid_base_class owner
+      alias proxied_owner owner
+      alias to_sym name
+
       delegate :namespaces, to: :owner
+      delegate :input_type?, :output_type?, :leaf_type?, :proxy?,
+        :mutation?, :subscription?, to: :class
 
       class << self
         # A small shared helper method that allows field information to be
         # proxied
         def proxyable_methods(*list, klass:, allow_nil: false)
           list = list.flatten.compact.map do |method_name|
-            ivar = '@' + method_name.delete_suffix('?')
-            accessor = 'field' + (allow_nil ? '&.' : '.') + method_name
+            ivar = +'@' + method_name.delete_suffix('?')
+            accessor = +'field' + (allow_nil ? '&.' : '.') + method_name
             "def #{method_name}; defined?(#{ivar}) ? #{ivar} : #{accessor}; end"
           end
 
@@ -89,13 +94,21 @@ module Rails # :nodoc:
         def mutation?
           false
         end
+
+        # Checks if the field is associated with a subscription
+        def subscription?
+          false
+        end
       end
 
       def initialize(name, owner:, **xargs, &block)
         @owner = owner
         normalize_name(name)
 
-        @directives = GraphQL.directives_to_set(xargs[:directives], source: self)
+        # TODO: Replace by a proper method to build and set @directives
+        directives = GraphQL.directives_to_set(xargs[:directives], source: self)
+        @directives = directives unless directives.nil?
+
         @method_name = xargs[:method_name].to_s.underscore.to_sym \
           unless xargs[:method_name].nil?
 
@@ -104,13 +117,13 @@ module Rails # :nodoc:
         @array    = full ? true  : xargs.fetch(:array, false)
         @nullable = full ? false : xargs.fetch(:nullable, true)
 
-        @desc = xargs[:desc]&.strip_heredoc&.chomp
+        self.description = xargs[:desc]
         @enabled = xargs.fetch(:enabled, !xargs.fetch(:disabled, false))
 
         configure(&block) if block.present?
       end
 
-      def initialize_copy(*) # :nodoc:
+      def initialize_copy(*)
         super
 
         @owner = nil
@@ -123,7 +136,7 @@ module Rails # :nodoc:
         disable! if xargs.fetch(:disabled, false)
         enable! if xargs.fetch(:enabled, false)
 
-        @desc = xargs[:desc].strip_heredoc.chomp if xargs.key?(:desc)
+        self.description = xargs[:desc] if xargs.key?(:desc)
         configure(&block) if block.present?
       end
 
@@ -132,22 +145,40 @@ module Rails # :nodoc:
         Field::ScopedConfig.new(self, block.binding.receiver).instance_exec(&block)
       end
 
+      # Return the owner as the single item of the list
+      def all_owners
+        [owner]
+      end
+
       # Returns the name of the method used to retrieve the information
       def method_name
-        defined?(@method_name) ? @method_name : @name
+        if defined?(@method_name)
+          @method_name
+        elsif from_alternative?
+          :resolve
+        else
+          @name
+        end
       end
 
-      # Check if the other field is equivalent
-      def =~(other)
-        other.is_a?(GraphQL::Field) &&
-          other.array? == array? &&
-          (other.null? == null? || other.null? && !null?) &&
-          (other.nullable? == nullable? || other.nullable? && !nullable?)
+      # Mark the field as globally enabled
+      def enable!
+        @enabled = true
       end
 
-      # Return the owner as the single item of the list
-      def all_owners
-        [owner]
+      # Mark the field as globally disabled
+      def disable!
+        @enabled = false
+      end
+
+      # Update the null value
+      def required!
+        @null = false
+      end
+
+      # Update the nullable value
+      def required_items!
+        @nullable = false
       end
 
       # Checks if the argument can be null
@@ -175,24 +206,9 @@ module Rails # :nodoc:
         !enabled?
       end
 
-      # Mark the field as globally enabled
-      def enable!
-        @enabled = true
-      end
-
-      # Mark the field as globally disabled
-      def disable!
-        @enabled = false
-      end
-
-      # Return the description of the argument
-      def description
-        @desc
-      end
-
-      # Checks if a description was provided
-      def description?
-        defined?(@desc) && !!@desc
+      # Override to add the kind
+      def description(namespace = nil, *)
+        super(namespace, :field)
       end
 
       # Check if the field is an internal one
@@ -241,22 +257,12 @@ module Rails # :nodoc:
       def validate!(*)
         super if defined? super
 
-        raise NameError, <<~MSG.squish if gql_name.start_with?('__') && !internal?
+        raise NameError, (+<<~MSG).squish if gql_name.start_with?('__') && !internal?
           The name "#{gql_name}" is invalid. Only internal fields from the
           spec can have a name starting with "__".
         MSG
       end
 
-      # Update the null value
-      def required!
-        @null = false
-      end
-
-      # Update the nullable value
-      def required_items!
-        @nullable = false
-      end
-
       # Create a proxy of the current field
       def to_proxy(*args, **xargs, &block)
         proxy = self.class.allocate
@@ -266,8 +272,16 @@ module Rails # :nodoc:
         proxy
       end
 
-      def inspect # :nodoc:
-        <<~INSPECT.squish + '>'
+      # Check if the other field is equivalent
+      def =~(other)
+        other.is_a?(GraphQL::Field) &&
+          other.array? == array? &&
+          (other.null? == null? || other.null? && !null?) &&
+          (other.nullable? == nullable? || other.nullable? && !nullable?)
+      end
+
+      def inspect
+        (+<<~INFO).squish << '>'
           #<#{self.class.name}
           #{inspect_owner}
           #{inspect_source}
@@ -275,7 +289,7 @@ module Rails # :nodoc:
           #{gql_name}#{inspect_arguments}#{inspect_type}
           #{inspect_default_value}
           #{inspect_directives}
-        INSPECT
+        INFO
       end
 
       protected
@@ -304,9 +318,9 @@ module Rails # :nodoc:
           end
         end
 
-        # Helper method to inspect the directives
-        def inspect_directives
-          all_directives.map(&:inspect)
+        # Check if the field was defined as an alternative class
+        def from_alternative?
+          proxied_owner.is_a?(Module) && proxied_owner <= Alternative::Query
         end
 
         # Show the name of the owner of the object for inspection

data/lib/rails/graphql/global_id.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'globalid'
+
+module Rails
+  module GraphQL
+    # = GraphQL Global ID
+    #
+    # GraphQL implementation of the Global ID that adds extended support to how
+    # things are located and stored. Mostly used for caching and custom access
+    # to the tree and request process.
+    #
+    # TODO: Implement signed operations
+    class GlobalID < ::GlobalID
+      SERIALIZER_KEY = "_gql_globalid"
+
+      # This adds support to ActiveJob serialization, which can be used to pass
+      # GraphQL objects to jobs and also deserialize things for subscriptions
+      class Serializer
+        include Singleton
+
+        class << self
+          delegate :serialize?, :serialize, :deserialize, to: :instance
+        end
+
+        # Determines if an argument should be serialized by this serializer.
+        def serialize?(argument)
+          argument.is_a?(Helpers::WithGlobalID) || argument.class.is_a?(Helpers::WithGlobalID)
+        end
+
+        # Serializes an argument to a JSON primitive type.
+        def serialize(argument)
+          { GlobalID::SERIALIZER_KEY => argument.to_global_id.to_s }
+        end
+
+        # Deserializes an argument from a JSON primitive type.
+        def deserialize(argument)
+          GlobalID.find argument[GlobalID::SERIALIZER_KEY]
+        end
+
+        private
+          # The class of the object that will be serialized.
+          def klass
+            GlobalID
+          end
+      end
+
+      class << self
+        undef_method :app, :app=
+
+        # Create a new GraphQL Global identifier
+        def create(object, options = nil)
+          scope = options&.delete(:scope) || scope_of(object)
+          new(URI::GQL.create(object, scope, options), options)
+        end
+
+        # Find the scope on which the object is applied to
+        def scope_of(object)
+          object.try(:schema_type) if object.gid_base_class.is_a?(Helpers::WithSchemaFields)
+        end
+      end
+
+      undef_method :app, :model_name, :model_id
+      delegate :namespace, :class_name, :scope, :name, :instantiate?, to: :uri
+
+      def initialize(gid, options = {})
+        @uri = gid.is_a?(URI::GQL) ? gid : URI::GQL.parse(gid)
+      end
+
+      def find(options = {})
+        base_class.try(:find_by_gid, self)
+      end
+
+      def base_class
+        ::GraphQL.const_get(class_name, false)
+      end
+
+      def ==(other)
+        other.is_a?(GlobalID) && @uri == other.uri
+      end
+
+      alias eql? ==
+    end
+  end
+end

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Helpers # :nodoc:
+module Rails
+  module GraphQL
+    module Helpers
       # 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
@@ -14,11 +14,11 @@ module Rails # :nodoc:
 
         private
 
-          def respond_to_missing?(method_name, include_private = false) # :nodoc:
+          def respond_to_missing?(method_name, include_private = false)
             __getobj__.respond_to?(method_name, include_private) || super
           end
 
-          def method_missing(method_name, *args, **xargs, &block) # :nodoc:
+          def method_missing(method_name, *args, **xargs, &block)
             return super unless __getobj__.respond_to?(method_name)
             __getobj__.public_send(method_name, *args, **xargs, &block)
           end

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

@@ -0,0 +1,50 @@
+module Rails
+  module GraphQL
+    module Helpers
+      # A inherited collection of arrays that can be unique when it is a set
+      class InheritedCollection::Array < InheritedCollection::Base
+        alias size count
+
+        # Provide similar functionality of any? but returns the object instead
+        def find(value = nil, &block)
+          block ||= !value.is_a?(Module) ? value.method(:==) : ->(val) { val.class <= value }
+          reverse_each { |item| return item if block.call(item) }
+          nil
+        end
+
+        # Check if a given +value+ is included in any of the definitions
+        def include?(value)
+          each_definition.any? { |definition| definition.include?(value) }
+        end
+
+        # If any elements appears, the each block will run and return true
+        def empty?
+          lazy.each { return true }
+          false
+        end
+
+        # The normal each is the reverse each of the definitions
+        def each(&block)
+          lazy.reverse_each(&block)
+        end
+
+        # The reverse each is the normal each of the definitions
+        def reverse_each(&block)
+          block.nil? ? lazy : lazy.each(&block)
+        end
+
+        # Overrides the lazy operator
+        def lazy
+          (@type == :set) ? super.uniq : super
+        end
+
+        # Allow concatenating objects
+        def +(other)
+          result = to_a
+          result = result.to_set if @type == :set
+          result + other
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Rails
+  module GraphQL
+    module Helpers
+      # The base class for inherited collections. It helps softly dealing with
+      # values defined in multiple class instance variables and look up the tree
+      # to make it possible to iterate over combined result
+      class InheritedCollection::Base
+        include Enumerable
+
+        # 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
+          InheritedCollection.const_get(klass).new(source, ivar, type)
+        end
+
+        def initialize(source, ivar, type)
+          @source = source
+          @ivar = ivar
+          @type = type
+        end
+
+        # Overrides the lazy enumerator because each instance variable defined
+        # and found by the +each_definition+ will be iterated over lazily
+        def lazy
+          Enumerator::Lazy.new(each_definition) { |y, d| d.each(&y) }
+        end
+
+        protected
+
+          def each_definition
+            Enumerator.new do |yielder|
+              current = @source
+              until current === Object
+                yielder << current.instance_variable_get(@ivar) \
+                  if current.instance_variable_defined?(@ivar)
+                current = current.superclass
+              end
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+module Rails
+  module GraphQL
+    module Helpers
+      # A inherited collection of Hash that can contain simple values, arrays,
+      # or sets
+      class InheritedCollection::Hash < InheritedCollection::Base
+        delegate :transform_values, :transform_keys, to: :to_hash
+
+        # Simply go over each definition and check for the given key
+        def key?(value)
+          each_definition.any? { |definition| definition.key?(value) }
+        end
+
+        # Collect all the keys of all the definitions
+        def keys
+          each_definition.reverse_each.flat_map(&:keys).uniq
+        end
+
+        # Go over each key and value
+        def each
+          Enumerator::Lazy.new(keys) do |yielder, key|
+            val = self[key]
+            yield(key, val) if block_given?
+            yielder.yield(key, val)
+          end
+        end
+
+        # Go over each value exclusively
+        def each_value(&block)
+          Enumerator::Lazy.new(keys) do |yielder, key|
+            val = self[key]
+            yield(val) if block_given?
+            yielder.yield(val)
+          end
+        end
+
+        # Go over each key exclusively
+        def each_key(&block)
+          keys.each(&block)
+        end
+
+        # Get all the values by lazy iterating over all the keys
+        def values
+          keys.lazy.map(&method(:[]))
+        end
+
+        # Basically allow this lazy operator to be merged with other hashes
+        def to_hash
+          each.to_h
+        end
+
+        # A simple way to get the result of one single key
+        def [](key)
+          lazy[key]
+        end
+
+        # Build a lazy hash
+        def lazy
+          @table ||= Hash.new(&method(_combine? ? :_combined_hash : :_simple_hash))
+        end
+
+        private
+
+          # Check if it has to combine the values
+          def _combine?
+            @type != :hash
+          end
+
+          # Builds a values for a combined hash
+          def _combined_hash(hash, key)
+            hash[key] = each_definition.reverse_each.inject(nil) do |result, definition|
+              next result unless definition.key?(key)
+              next definition[key] if result.nil?
+              result + definition[key]
+            end
+          end
+
+          # Builds a values for a simple hash
+          def _simple_hash(hash, key)
+            hash[key] = each_definition.reverse_each do |definition|
+              break definition[key] if definition.key?(key)
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -1,15 +1,22 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Helpers # :nodoc:
-      module InheritedCollection # :nodoc:
+module Rails
+  module GraphQL
+    module Helpers
+      # Helper module that allow classes to have specific type of attributes
+      # that are corretly delt when it is inherited by another class. It keeps
+      # track of its own value and allow access to all values of the property
+      # in the tree,
+      #
+      # TODO: Rewrite this!
+      module InheritedCollection
+        # All possible types of inheritable values
         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 }',
+          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
@@ -60,20 +67,19 @@ module Rails # :nodoc:
           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
+            instance_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+              def all_#{name}
+                return superclass.try(:all_#{name}) unless defined?(@#{name})
+                InheritedCollection::Base.handle(self, :@#{name}, :#{type})
               end
 
-              def self.#{name}
+              def #{name}
                 @#{name} ||= #{DEFAULT_TYPES[type]}
               end
             RUBY
 
-            module_eval(<<~RUBY, __FILE__, __LINE__ + 1) if instance_predicate
-              def self.#{name}?
+            instance_eval(<<~RUBY, __FILE__, __LINE__ + 1) if instance_predicate
+              def #{name}?
                 (defined?(@#{name}) && @#{name}.present?) || superclass.try(:#{name}?)
               end
             RUBY
@@ -84,69 +90,12 @@ module Rails # :nodoc:
             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
+
+require_relative 'inherited_collection/base'
+
+require_relative 'inherited_collection/array'
+require_relative 'inherited_collection/hash'

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    module Helpers
+      # This marks an object as instantiable during a requesting, which means it
+      # will be associated with an event and most of it's information comes from
+      # the running event.
+      module Instantiable
+        delegate_missing_to :event
+        attr_reader :event
+      end
+    end
+  end
+end