rails-graphql 0.2.1 → 1.0.0.rc1

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # This is a helper module that basically works with fields that have an
     # assigned type value
     module Field::TypedField
@@ -13,14 +13,9 @@ module Rails # :nodoc:
 
       delegate :input_type?, :output_type?, :leaf_type?, :kind, to: :type_klass
 
-      def initialize(name, type, *args, **xargs, &block)
-        if type.is_a?(Module) && type < GraphQL::Type
-          @type_klass = type
-          @type = type.to_sym
-        else
-          @type = type.to_s.underscore.to_sym
-        end
-
+      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
 
@@ -32,11 +27,11 @@ module Rails # :nodoc:
 
       # 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
-      # will be associated to the object valyd types
+      # will be associated to the object valid types
       def valid_field_types
         owner.try(:valid_field_types) || Type::Object.valid_field_types
       end
@@ -55,29 +50,67 @@ module Rails # :nodoc:
         )
       end
 
+      alias type_class type_klass
+
       # Add the listeners from the associated type
       def all_listeners
-        type_klass.all_listeners + super
+        inherited = super
+        return inherited unless type_klass.listeners?
+        inherited.present? ? inherited + type_klass.all_listeners : type_klass.all_listeners
+      end
+
+      # Make sure to check the associated type
+      def listeners?
+        super || type_klass.listeners?
       end
 
       # Add the events from the associated type
       def all_events
-        Helpers.merge_hash_array(type_klass.all_events, super)
+        inherited = super
+        return inherited unless type_klass.events?
+        return type_klass.all_events if inherited.blank?
+        Helpers.merge_hash_array(inherited, type_klass.all_events)
+      end
+
+      # Make sure to check the associated type
+      def events?
+        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
 
-        raise ArgumentError, <<~MSG.squish unless type_klass.is_a?(Module)
-          Unable to find the "#{type.inspect}" input type on GraphQL context.
+        raise ArgumentError, (+<<~MSG).squish unless type_klass.is_a?(Module)
+          Unable to find the "#{type.inspect}" data type on GraphQL context.
         MSG
 
         valid_type = valid_field_types.empty? || valid_field_types.any? do |base_type|
           type_klass < base_type
         end
 
-        raise ArgumentError, <<~MSG.squish unless valid_type
+        raise ArgumentError, (+<<~MSG).squish unless valid_type
           The "#{type_klass.base_type}" is not accepted in this context.
         MSG
       end
@@ -86,16 +119,28 @@ module Rails # :nodoc:
 
         # Little helper that shows the type of the field
         def inspect_type
-          result = ': '
-          result += '[' if array?
-          result += type_klass.gql_name
-          result += '!' if array? && !nullable?
-          result += ']' if array?
-          result += '!' unless null?
+          result = +': '
+          result << '[' if array?
+          result << type_klass.gql_name
+          result << '!' if array? && !nullable?
+          result << ']' if array?
+          result << '!' unless null?
           result
         end
 
-        def proxied # :nodoc:
+        # A little hidden helper to support forcing reassignment of type, which
+        # should only be done with caution
+        def assign_type(type)
+          if type.is_a?(Module) && type < GraphQL::Type
+            @type_klass = type
+            @type = type.to_sym
+          else
+            @type_klass = nil
+            @type = type
+          end
+        end
+
+        def proxied
           super if defined? super
           extend Field::TypedField::Proxied
         end

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,11 +20,9 @@ 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
+    # * <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).
@@ -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] || xargs[:description]
         @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,44 +136,69 @@ 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)
+        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
+      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
 
-      # Checks if the argument can be null
+      # Update the null value
+      def required!
+        @null = false
+      end
+
+      # Update the nullable value
+      def required_items!
+        @nullable = false
+      end
+
+      # 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
@@ -175,24 +213,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
@@ -211,24 +234,18 @@ module Rails # :nodoc:
       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
@@ -241,22 +258,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,16 +273,24 @@ module Rails # :nodoc:
         proxy
       end
 
-      def inspect # :nodoc:
-        <<~INSPECT.squish + '>'
-          #<#{self.class.name}
-          #{inspect_owner}
+      # 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 << '>'
+          #<GraphQL::#{self.class.name.split('::').last}
+          #{inspect_owner&.split(+'GraphQL::')&.last&.sub(+'::NestedTypes', '')}
           #{inspect_source}
           #{inspect_enabled}
           #{gql_name}#{inspect_arguments}#{inspect_type}
           #{inspect_default_value}
           #{inspect_directives}
-        INSPECT
+        INFO
       end
 
       protected
@@ -304,9 +319,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,89 @@
+# 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
+        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)
+        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,51 @@
+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
+        alias to_ary eager
+
+        # 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,45 @@
+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
+
+        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
+          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