rails-graphql 0.2.0 → 1.0.0.beta

data/lib/rails/graphql/type/union.rb

@@ -1,27 +1,23 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Type # :nodoc:
+module Rails
+  module GraphQL
+    class Type
       # = GraphQL UnionType
       #
       # Unions represent an object that could be one of a list of GraphQL
       # Object types.
       # See http://spec.graphql.org/June2018/#UnionTypeDefinition
       class Union < Type
+        include Helpers::Instantiable
+
         setup! output: true
 
         # The list of accepted classes for members
         VALID_MEMBER_TYPES = [Type::Object].freeze
 
         # Define the methods for accessing the members attribute
-        inherited_collection :members
-
-        # The purpose of instantiating an interface is to have access to its
-        # public methods. It then runs from the strategy perspective, pointing
-        # out any other methods to the manually set event
-        delegate_missing_to :event
-        attr_reader :event
+        inherited_collection :members, instance_reader: false
 
         class << self
           # Return the base type of the objects on this union
@@ -46,12 +42,12 @@ module Rails # :nodoc:
             end
 
             checker = others.lazy.map { |item| item.try(:base_type) }.uniq.force
-            raise ArgumentError, <<~MSG.squish unless checker.size === 1
+            raise ArgumentError, (+<<~MSG).squish unless checker.size === 1
               All the union members must be of the same base class.
             MSG
 
             check_types = members? ? [members.first.base_type] : VALID_MEMBER_TYPES
-            raise ArgumentError, <<~MSG.squish unless (check_types & checker).size === 1
+            raise ArgumentError, (+<<~MSG).squish unless (check_types & checker).size === 1
               A union cannot contain members of different base classes.
             MSG
 
@@ -63,21 +59,23 @@ module Rails # :nodoc:
             super if defined? super
 
             members = all_members
-            raise ArgumentError, <<~MSG.squish unless members.size >= 1
+            raise ArgumentError, (+<<~MSG).squish unless members.size >= 1
               A union must contain at least one member.
             MSG
 
             size = members.lazy.map(&:base_type).uniq.force.size
-            raise ArgumentError, <<~MSG.squish unless size.eql?(1)
+            raise ArgumentError, (+<<~MSG).squish unless size.eql?(1)
               All the members of the union must contain the same base class.
             MSG
           end
 
-          def inspect # :nodoc:
-            <<~INFO.squish + '>'
+          def inspect
+            return super if self.eql?(Type::Union)
+            (+<<~INFO).squish << '>'
               #<GraphQL::Union #{gql_name}
               (#{all_members.size})
               {#{all_members.map(&:gql_name).join(' | ')}}
+              #{inspect_directives}
             INFO
           end
         end

data/lib/rails/graphql/type.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = GraphQL Type
     #
     # This is the most pure object from GraphQL. Anything that a schema can
@@ -10,18 +10,19 @@ module Rails # :nodoc:
     class Type
       extend ActiveSupport::Autoload
       extend Helpers::WithDirectives
+      extend Helpers::WithGlobalID
       extend Helpers::Registerable
 
       # A direct representation of the spec types
       KINDS = %w[Scalar Object Interface Union Enum Input].freeze
-      eager_autoload { KINDS.each { |kind| autoload kind.to_sym } }
+      KINDS.each { |kind| autoload kind.to_sym }
 
       delegate :base_type, :kind, :kind_enum, :input_type?, :output_type?,
         :leaf_type?, to: :class, prefix: :gql
 
       # A +base_object+ helps to identify what methods are actually available
       # to work as resolvers
-      class_attribute :base_object, instance_writer: false, default: false
+      class_attribute :base_object, instance_accessor: false, default: false
 
       self.spec_object = true
       self.base_object = true
@@ -36,6 +37,12 @@ module Rails # :nodoc:
           nil
         end
 
+        # This cannot be defined using alias because the +base_type+ method is
+        # overridden by all children classes
+        def gid_base_class
+          base_type
+        end
+
         # Check if the other type is equivalent
         def =~(other)
           (other.is_a?(Module) ? other : other.class) <= self
@@ -68,35 +75,32 @@ module Rails # :nodoc:
           false
         end
 
+        # Defines if the object is a source of operations, which is only used
+        # for fake base types like +_Query+ and +_Mutation+
+        def operational?
+          false
+        end
+
         # A little helper to instanteate the type if necessary
         def decorate(value)
           value
         end
 
-        # Checks if a given method can act as resolver
-        def gql_resolver?(method_name)
-          ref_object = self
-          ref_object = ref_object.superclass until ref_object.base_object?
-          (instance_methods - ref_object.instance_methods).include?(method_name)
+        # Return the type object, instantiate if it has params
+        def find_by_gid(gid)
+          options = { namespaces: gid.namespace.to_sym, base_class: :Type }
+          klass = GraphQL.type_map.fetch!(gid.name, **options)
+          gid.instantiate? ? klass.build(**gid.params) : klass
         end
 
-        # Defines a series of question methods based on the kind
-        KINDS.each { |kind| define_method("#{kind.downcase}?") { false } }
-
-        def eager_load! # :nodoc:
-          super
-
-          # Due to inheritance
-          return unless eql?(GraphQL::Type)
-
-          Type::Enum.eager_load!
-          Type::Object.eager_load!
-          Type::Scalar.eager_load!
-
-          Source.eager_load!
-          TypeMap.loaded! :Type
+        # Similar to inspect, but summarized
+        def to_gql_backtrace
+          +"#<GraphQL::#{base_type.name.demodulize} #{gql_name}>"
         end
 
+        # Defines a series of question methods based on the kind
+        KINDS.each { |kind| define_method(:"#{kind.downcase}?") { false } }
+
         protected
 
           # Provide a list of settings to setup the current child class
@@ -111,6 +115,11 @@ module Rails # :nodoc:
             redefine_singleton_method(:output_type?) { true } if options[:output]
           end
 
+          # Check if the value is a valid parser token
+          def valid_token?(value, type = to_sym)
+            value.is_a?(::GQLParser::Token) && value.of_type?(type)
+          end
+
         private
 
           # Reset some class attributes, meaning that they are not cascade
@@ -118,7 +127,7 @@ module Rails # :nodoc:
             if subclass.superclass.eql?(GraphQL::Type)
               subclass.redefine_singleton_method(:base_type) { subclass }
 
-              question_method = "#{subclass.name.demodulize.underscore}?"
+              question_method = :"#{subclass.name.demodulize.underscore}?"
               subclass.redefine_singleton_method(question_method) { true }
 
               subclass.spec_object = true