rails-graphql 0.2.1 → 1.0.0.rc1

data/lib/rails/graphql/to_gql.rb

@@ -3,8 +3,8 @@
 require 'arel/visitors/visitor'
 
 # rubocop:disable Naming/MethodParameterName, Naming/MethodName
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = GraphQL ToGQL
     #
     # This class can turn any class related to GraphQL into its GraphQL string
@@ -35,14 +35,13 @@ module Rails # :nodoc:
         collector ||= Collectors::IdentedCollector.new
         @with_descriptions = with_descriptions
         @with_spec = with_spec.nil? ? schema.introspection? : with_spec
+        @namespace = schema.namespace
 
-        accept(schema, collector).eol
-
-        GraphQL.type_map.each_from(schema.namespace, base_class: :Type)
+        GraphQL.type_map.each_from(@namespace, base_class: :Type)
           .group_by(&:kind).values_at(*DESCRIBE_TYPES)
-          .each do |items|
+          .prepend([schema]).each do |items|
             items&.sort_by(&:gql_name)&.each do |item|
-              next if !@with_spec && item.internal?
+              next if !@with_spec && item.try(:internal?)
 
               next visit_Rails_GraphQL_Type_Object(item, collector).eol \
                 if item.is_a?(::OpenStruct) && item.object?
@@ -109,8 +108,9 @@ module Rails # :nodoc:
           visit_directives(o.directives, collector)
 
           collector.indented(' {', '}') do
-            Helpers::WithSchemaFields::SCHEMA_FIELD_TYPES.each do |key, name|
+            Helpers::WithSchemaFields::TYPE_FIELD_CLASS.each_key do |key|
               next unless key.eql?(:query) || o.fields_for(key).present?
+              name = o.type_name_for(key)
 
               collector << key.to_s
               collector << ': '
@@ -152,14 +152,6 @@ module Rails # :nodoc:
           visit_Rails_GraphQL_Field(o, collector)
         end
 
-        def visit_Rails_GraphQL_Field_OutputField(o, collector)
-          visit_Rails_GraphQL_Field(o, collector)
-        end
-
-        def visit_Rails_GraphQL_Field_InputField(o, collector)
-          visit_Rails_GraphQL_Field(o, collector)
-        end
-
         def visit_Rails_GraphQL_Type_Enum(o, collector)
           visit_description(o, collector)
           collector << 'enum '
@@ -178,9 +170,7 @@ module Rails # :nodoc:
           collector << o.gql_name
           visit_directives(o.directives, collector)
 
-          collector.indented(' {', '}') do
-            o.fields.each_value { |x| visit(x, collector) }
-          end
+          collector.indented(' {', '}') { visit_fields(o.fields, collector) }
         end
 
         def visit_Rails_GraphQL_Type_Interface(o, collector)
@@ -190,9 +180,7 @@ module Rails # :nodoc:
           collector << o.gql_name
           visit_directives(o.directives, collector)
 
-          collector.indented(' {', '}') do
-            o.fields.each_value { |x| visit(x, collector) }
-          end
+          collector.indented(' {', '}') { visit_fields(o.fields, collector) }
         end
 
         def visit_Rails_GraphQL_Type_Object(o, collector)
@@ -211,9 +199,7 @@ module Rails # :nodoc:
 
           visit_directives(o.directives, collector)
 
-          collector.indented(' {', '}') do
-            o.fields.each_value { |x| visit(x, collector) }
-          end
+          collector.indented(' {', '}') { visit_fields(o.fields, collector) }
         end
 
         def visit_Rails_GraphQL_Type_Scalar(o, collector)
@@ -260,8 +246,16 @@ module Rails # :nodoc:
           visit_typed_object(o, collector)
         end
 
+        def visit_fields(list, collector)
+          return if list.blank?
+
+          list.values.sort_by do |field|
+            field.name == :id ? '' : field.gql_name
+          end.each { |x| visit(x, collector) }
+        end
+
         def visit_arguments(list, collector)
-          return if list.empty?
+          return if list.blank?
 
           indented = @with_descriptions && list.values.any?(&:description?)
 
@@ -292,15 +286,18 @@ module Rails # :nodoc:
         end
 
         def visit_description(o, collector)
-          return unless @with_descriptions && o.description?
+          return unless @with_descriptions
+
+          args = o.method(:description).arity == 0 ? [] : [@namespace]
+          return if (desc = o.description(*args)).nil?
 
-          if o.description.lines.size === 1
-            collector << o.description.inspect
+          if desc.lines.size === 1
+            collector << desc.inspect
           else
             collector << '"""'
             collector.eol
 
-            collector << o.description
+            collector << desc
             collector.eol
 
             collector << '"""'
@@ -344,7 +341,7 @@ module Rails # :nodoc:
           collector << ' = ' << o.to_json(o.default) if o.try(:default_value?)
         end
 
-        def visit(object, collector = nil) # :nodoc:
+        def visit(object, collector = nil)
           object_class = object.is_a?(Module) ? object : object.class
           dispatch_method = dispatch[object_class]
           if collector
@@ -358,7 +355,7 @@ module Rails # :nodoc:
             respond_to?(dispatch[klass], true)
           end
 
-          raise(::TypeError, "Cannot visit #{object_class}") unless superklass
+          raise(::TypeError, +"Cannot visit #{object_class}") unless superklass
           dispatch[object_class] = dispatch[superklass]
           retry
         end

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

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    class Type
+      # = GraphQL Type Creator
+      #
+      # This class helps to dynamically create types using a large set of
+      # settings that are provided through the named arguments. There are
+      # setting that are general to all types, and some are specific per base
+      # type of the superclass
+      class Creator
+        NESTED_MODULE = :NestedTypes
+        SUPPORTED_KINDS = %i[scalar object interface union enum input_object source].freeze
+
+        attr_reader :name, :superclass, :klass, :settings
+
+        delegate :type_map, to: '::Rails::GraphQL'
+        delegate :kind, to: :superclass
+
+        # Simply instantiate the creator and run the process
+        def self.create!(*args, **xargs, &block)
+          new(*args, **xargs).create!(&block)
+        end
+
+        def initialize(from, name_or_object, superclass, **settings)
+          @from = from
+          @settings = settings
+          @object = name_or_object if name_or_object.is_a?(Class)
+
+          @superclass = sanitize_superclass(superclass)
+          @name = sanitize_name(name_or_object)
+        end
+
+        # Go over the create process
+        def create!(&block)
+          @klass = find_or_create_class
+          klass.instance_variable_set(:@gql_name, gql_name)
+
+          apply_general_settings
+          after_block = apply_specific_settings
+
+          klass.module_exec(&block) if block.present?
+          after_block.call if after_block.is_a?(Proc)
+          klass
+        end
+
+        protected
+
+          # Use the type map to look for a type from the same namespace
+          def find_type!(value)
+            type_map.fetch!(value, namespaces: namespaces, base_class: :Type)
+          end
+
+          # Same as above, but mapping the list
+          def find_all_types!(*list)
+            list.map { |item| item.is_a?(Class) ? item : find_type!(item) }
+          end
+
+          # Apply settings that is common for any possible type created
+          def apply_general_settings
+            klass.abstract = settings[:abstract] if settings.key?(:abstract)
+            klass.set_namespace(*namespaces)
+
+            klass.use(*settings[:directives]) if settings.key?(:directives) &&
+              klass.is_a?(Helpers::WithDirectives)
+
+            if klass.is_a?(Helpers::WithAssignment)
+              assignment = settings.fetch(:assigned_to, @object)
+              klass.assigned_to = assignment unless assignment.nil?
+            end
+
+            if settings.key?(:owner)
+              klass.include(Helpers::WithOwner) unless klass.is_a?(Helpers::WithOwner)
+              klass.owner = settings[:owner] == true ? @from : settings[:owner]
+            end
+          end
+
+          # Using the kind, call of a specific method to further configure the
+          # created class
+          def apply_specific_settings
+            method_name = +"apply_#{kind}_settings"
+            send(method_name) if respond_to?(method_name, true)
+          end
+
+          # Specific settings when creating an enum
+          def apply_enum_settings
+            klass.indexed! if settings[:indexed]
+            return if (values = settings[:values]).nil?
+            GraphQL.enumerate(values).each(&klass.method(:add))
+          end
+
+          # Specific settings when creating an union
+          def apply_union_settings
+            types = settings[:of_types]
+            klass.append(*find_all_types!(*types)) unless types.nil?
+          end
+
+          # Specific settings when creating a source
+          def apply_source_settings
+            build = settings[:build]
+
+            -> do
+              return klass.build_all if build == true
+              GraphQL.enumerate(build).each do |step|
+                klass.public_send(+"build_#{step}")
+              end
+            end if build
+          end
+
+        private
+
+          # Either get the gql name from settings or properly resolve one from
+          # the name
+          def gql_name
+            settings[:gql_name].presence || begin
+              gql_name = name.dup
+              gql_name = gql_name.chomp(name_suffix) unless kind == :input_object
+              gql_name.tr('_', '')
+            end
+          end
+
+          # Add the nested module to the source of the creating and create the
+          # class. If any of those exist, return the constant instead
+          def find_or_create_class
+            base = base_module
+
+            # Create the class under the nested module
+            return base.const_set(name, Class.new(superclass)) \
+              unless base.const_defined?(name)
+
+            # Get the existing class and check for the once setting
+            klass = base.const_get(name)
+            return klass unless !once? && klass < superclass
+
+            # Created once or not from the same superclass
+            raise DuplicatedError, (+<<~MSG).squish
+              A type named "#{name}" already exists for the "#{base.name}" module.
+            MSG
+          end
+
+          # Make sure to properly get the superclass
+          def sanitize_superclass(value)
+            value = Type.const_get(value.to_s.classify) unless value.is_a?(Class)
+
+            valid_class = value.is_a?(Class) && value.respond_to?(:kind)
+            valid_class &= SUPPORTED_KINDS.include?(value.kind)
+            return value if valid_class
+
+            raise ::ArgumentError, +"The \"#{value.inspect}\" is not a valid superclass."
+          rescue ::NameError
+            raise ::ArgumentError, +"Unable to find a \"#{value}\" superclass."
+          end
+
+          # Let's clean up the name
+          def sanitize_name(name_or_object)
+            name = name_or_object.is_a?(Module) ? name_or_object.name : name_or_object.to_s
+            name = name.classify.gsub(/::/, '_')
+            name.end_with?(name_suffix) ? name : name + name_suffix
+          end
+
+          # Figure out the suffix that is supposed to be used for the name
+          def name_suffix
+            @name_suffix ||= @settings[:suffix] || begin
+              if kind == :input_object
+                GraphQL.config.auto_suffix_input_objects
+              else
+                superclass.kind.to_s.classify
+              end
+            end
+          end
+
+          # Get or set the base module using the from argument
+          def base_module
+            base = @from.is_a?(Module) ? @from : @from.class
+            if base.const_defined?(NESTED_MODULE, false)
+              base.const_get(NESTED_MODULE)
+            else
+              base.const_set(NESTED_MODULE, Module.new)
+            end
+          end
+
+          # Get the namespaces from the settings or from the source
+          def namespaces
+            @namespaces ||= settings[:namespace] || settings[:namespaces] || @from.namespace
+          end
+
+          # Check if the type should be create only once, meaning that returning
+          # an existing one is not an option
+          def once?
+            settings.fetch(:once, true)
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/type/enum/directive_location_enum.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Type # :nodoc:
+module Rails
+  module GraphQL
+    class Type
       # Bigint basically removes the limit of the value, but it serializes as
       # a string so it won't go against the spec
       class Enum::DirectiveLocationEnum < Enum
@@ -12,17 +12,17 @@ module Rails # :nodoc:
 
         desc 'The valid locations that a directive may be placed.'
 
-        %w[QUERY MUTATION SUBSCRIPTION FIELD FRAGMENT_DEFINITION
-          FRAGMENT_SPREAD INLINE_FRAGMENT].each do |value|
-          desc = value.downcase.tr('_', ' ')
-          add(value, desc: "Mark as a executable directive usable on #{desc} objects.")
+        Directive::EXECUTION_LOCATIONS.each do |value|
+          name = value.to_s.upcase
+          desc = value.to_s.tr('_', ' ')
+          add(name, desc: "Mark as a executable directive usable on #{desc} objects.")
         end
 
-        %w[SCHEMA SCALAR OBJECT FIELD_DEFINITION ARGUMENT_DEFINITION INTERFACE UNION
-          ENUM ENUM_VALUE INPUT_OBJECT INPUT_FIELD_DEFINITION].each do |value|
-          desc = value.downcase.tr('_', ' ')
+        Directive::DEFINITION_LOCATIONS.each do |value|
+          name = value.to_s.upcase
+          desc = value.to_s.tr('_', ' ')
           desc = "Mark as a type system directive usable on #{desc} definitions."
-          add(value, desc: desc.gsub(/definition definitions\.$/, 'definitions.'))
+          add(name, desc: desc.sub('definition definitions.', 'definitions.'))
         end
       end
     end

data/lib/rails/graphql/type/enum/type_kind_enum.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Type # :nodoc:
+module Rails
+  module GraphQL
+    class Type
       # Bigint basically removes the limit of the value, but it serializes as
       # a string so it won't go against the spec
       class Enum::TypeKindEnum < Enum

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    class Type # :nodoc:
+module Rails
+  module GraphQL
+    class Type
       # = GraphQL EnumType
       #
       # Enum types, like scalar types, also represent leaf values in a GraphQL
@@ -13,10 +13,8 @@ module Rails # :nodoc:
 
         setup! leaf: true, input: true, output: true
 
-        eager_autoload do
-          autoload :DirectiveLocationEnum
-          autoload :TypeKindEnum
-        end
+        autoload :DirectiveLocationEnum
+        autoload :TypeKindEnum
 
         # Define the methods for accessing the values attribute
         inherited_collection :values
@@ -25,7 +23,7 @@ module Rails # :nodoc:
         inherited_collection :value_description, type: :hash
 
         # Define the methods for accessing the directives of each enum value
-        inherited_collection :value_directives, type: :hash
+        inherited_collection :value_directives, type: :hash_set
 
         class << self
           # Mark the enum as indexed, allowing values being set by number
@@ -40,7 +38,8 @@ module Rails # :nodoc:
 
           # Check if a given value is a valid non-deserialized input
           def valid_input?(value)
-            value.is_a?(String) && all_values.include?(value)
+            (valid_token?(value, :enum) && all_values.include?(value.to_s)) ||
+              (value.is_a?(String) && all_values.include?(value))
           end
 
           # Check if a given value is a valid non-serialized output
@@ -63,7 +62,7 @@ module Rails # :nodoc:
 
           # Turn a user input of this given type into an ruby object
           def deserialize(value)
-            new(value) if valid_input?(value)
+            new(value.is_a?(::GQLParser::Token) ? value.to_s : value) if valid_input?(value)
           end
 
           # Use the instance as decorator
@@ -76,6 +75,7 @@ module Rails # :nodoc:
           # ==== Options
           #
           # * <tt>:desc</tt> - The description of the enum value (defaults to nil).
+          # * <tt>:description</tt> - Alias to the above.
           # * <tt>:directives</tt> - The list of directives associated with the value
           #   (defaults to nil).
           # * <tt>:deprecated</tt> - A shortcut that auto-attach a @deprecated
@@ -83,18 +83,19 @@ module Rails # :nodoc:
           #   but provide a string so it can be used as the reason of the deprecation.
           #   See {DeprecatedDirective}[rdoc-ref:Rails::GraphQL::Directive::DeprecatedDirective]
           #   (defaults to false).
-          def add(value, desc: nil, directives: nil, deprecated: false)
-            raise ArgumentError, <<~MSG.squish unless value.is_a?(String) && value.present?
+          def add(value, desc: nil, description: nil, directives: nil, deprecated: false)
+            value = value&.to_s
+            raise ArgumentError, (+<<~MSG).squish unless value.is_a?(String) && !value.empty?
               The "#{value}" is invalid.
             MSG
 
             value = value.upcase
-            raise ArgumentError, <<~MSG.squish if all_values.include?(value)
+            raise ArgumentError, (+<<~MSG).squish if all_values&.include?(value)
               The "#{value}" is already defined for #{gql_name} enum.
             MSG
 
-            directives = Array.wrap(directives)
-            directives << deprecated_klass.new(
+            directives = ::Array.wrap(directives)
+            directives << Directive::DeprecatedDirective.new(
               reason: (deprecated.is_a?(String) ? deprecated : nil),
             ) if deprecated.present?
 
@@ -103,55 +104,52 @@ module Rails # :nodoc:
               source: self,
             )
 
+            desc = description if desc.nil?
+
             values << value
             value_description[value] = desc unless desc.nil?
-            value_directives[value] = directives
+            value_directives[value] = directives if directives
           end
 
           # Check if a given +value+ is using a +directive+
           def value_using?(value, directive)
-            raise ArgumentError, <<~MSG.squish unless directive < GraphQL::Directive
+            raise ArgumentError, (+<<~MSG).squish unless directive < GraphQL::Directive
               The provided #{item_or_symbol.inspect} is not a valid directive.
             MSG
 
-            !!value_directives[as_json(value)]&.any? { |item| item.is_a?(directive) }
+            all_value_directives.try(:[], as_json(value))&.any?(directive) || false
           end
 
           # Build a hash with deprecated values and their respective reason for
           # logging and introspection purposes
           def all_deprecated_values
             @all_deprecated_values ||= begin
-              all_value_directives.to_a.inject({}) do |list, (value, dirs)|
-                obj = dirs.find { |dir| dir.is_a?(deprecated_klass) }
-                obj ? list.merge(value => obj.args.reason) : list
+              all_value_directives&.each&.with_object({}) do |(value, dirs), hash|
+                obj = dirs&.find { |dir| dir.is_a?(Directive::DeprecatedDirective) }
+                hash[value] = obj.args.reason || true unless obj.nil?
               end
             end.freeze
           end
 
-          # This returns the field directives and all value directives
-          def all_directives
-            all_value_directives.each_value.reduce(:+)
-          end
+          def inspect
+            return super if self.eql?(Type::Enum)
 
-          def inspect # :nodoc:
-            <<~INFO.squish + '>'
+            values = all_values.to_a
+            (+<<~INFO).squish << '>'
               #<GraphQL::Enum #{gql_name}
-              (#{all_values.size})
-              {#{all_values.to_a.join(' | ')}}
+              (#{values.size})
+              {#{values.to_a.join(' | ')}}
+              #{inspect_directives}
             INFO
           end
-
-          private
-
-            def deprecated_klass
-              Directive::DeprecatedDirective
-            end
         end
 
         attr_reader :value
 
         delegate :to_s, :inspect, to: :@value
 
+        # TODO: Maybe add delegate missing
+
         def initialize(value)
           @value = value
         end
@@ -163,7 +161,7 @@ module Rails # :nodoc:
 
         # Allow finding the indexed position of the value
         def to_i
-          self.class.all_values.find_index(@value)
+          values.find_index(@value)
         end
 
         # Checks if the current value is valid
@@ -173,33 +171,29 @@ module Rails # :nodoc:
 
         # Gets all the description of the current value
         def description
-          @description ||= @value && self.class.all_value_description[@value]
+          return unless @value
+          return @description if defined?(@description)
+          @description = all_value_description.try(:[], @value)
         end
 
         # Gets all the directives associated with the current value
         def directives
-          @directives ||= @value && self.class.all_value_directives[@value]
+          return unless @value
+          return @directives if defined?(@directives)
+          @directives = all_value_directives.try(:[], @value)
         end
 
         # Checks if the current value is marked as deprecated
         def deprecated?
-          self.class.all_deprecated_values.include?(@value)
+          directives&.any?(Directive::DeprecatedDirective) || false
         end
 
         # Return the deprecated reason
         def deprecated_reason
-          deprecated_directive&.args&.reason
+          directives&.find do |dir|
+            dir.is_a?(Directive::DeprecatedDirective)
+          end&.args&.reason
         end
-
-        private
-
-          # Find and store the directive that marked the current value as
-          # deprecated
-          def deprecated_directive
-            @deprecated_directive ||= directives.find do |dir|
-              dir.is_a?(Directive::DeprecatedDirective)
-            end
-          end
       end
     end
   end