rails-graphql 0.2.1 → 1.0.0.rc1

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,21 @@ module Rails # :nodoc:
     class Type
       extend ActiveSupport::Autoload
       extend Helpers::WithDirectives
+      extend Helpers::WithGlobalID
       extend Helpers::Registerable
 
+      autoload :Creator
+
       # 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 +39,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,42 +77,45 @@ module Rails # :nodoc:
           false
         end
 
-        # A little helper to instanteate the type if necessary
+        # 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 instantiate 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!
+        # Similar to inspect, but summarized
+        def to_gql_backtrace
+          +"#<GraphQL::#{base_type.name.demodulize} #{gql_name}>"
+        end
 
-          Source.eager_load!
-          TypeMap.loaded! :Type
+        # Dynamically create a new type using the Creator
+        def create!(from, name, superclass = nil, **xargs, &configure)
+          Creator.create!(from, name, superclass || self, **xargs, &configure)
         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
           def setup!(**options)
             return unless superclass.eql?(GraphQL::Type)
 
-            redefine_singleton_method(:kind) { options[:kind] } if options.key?(:kind)
+            kind_value = options[:kind] || name.demodulize.underscore.to_sym
+            redefine_singleton_method(:kind) { kind_value }
             self.directive_location = kind
 
             redefine_singleton_method(:leaf_type?)   { true } if options[:leaf]
@@ -111,6 +123,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 +135,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