rails-graphql 0.2.1 → 1.0.0.rc1

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

@@ -1,40 +1,40 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Helpers # :nodoc:
+module Rails
+  module GraphQL
+    module Helpers
       # Helper module that allows other objects to hold schema fields (query,
       # mutation, and subscription fields). Works very similar to fields, but
       # they are placed in different places regarding their type.
       module WithSchemaFields
-        SCHEMA_FIELD_TYPES = %i[query mutation subscription].map do |key|
-          [key, "_#{key.to_s.classify}"]
-        end.to_h.freeze
-
         TYPE_FIELD_CLASS = {
           query:        'OutputField',
           mutation:     'MutationField',
-          subscription: 'OutputField',
+          subscription: 'SubscriptionField',
         }.freeze
 
-        module ClassMethods # :nodoc: all
+        module ClassMethods
           def inherited(subclass)
             super if defined? super
 
-            SCHEMA_FIELD_TYPES.each_key do |kind|
-              fields = instance_variable_defined?("@#{kind}_fields")
-              fields = fields ? instance_variable_get("@#{kind}_fields") : {}
-              fields.each_value { |field| subclass.add_proxy_field(kind, field) }
+            TYPE_FIELD_CLASS.each_key do |type|
+              fields = instance_variable_defined?("@#{type}_fields")
+              fields = fields ? instance_variable_get("@#{type}_fields") : EMPTY_HASH
+              fields.each_value { |field| subclass.add_proxy_field(type, field) }
             end
           end
         end
 
-        ScopedConfig = Struct.new(:source, :type) do # :nodoc: all
-          def arg(*args, **xargs, &block)
+        # Helper class to be used as the +self+ in configuration blocks
+        ScopedConfig = Struct.new(:source, :type) do
+          def argument(*args, **xargs, &block)
             xargs[:owner] ||= source
             GraphQL::Argument.new(*args, **xargs, &block)
           end
 
+          alias arg argument
+          alias kind type
+
           private
 
             def respond_to_missing?(method_name, include_private = false)
@@ -54,27 +54,44 @@ module Rails # :nodoc:
                 typed_methods = typed_methods.zip(typed_methods).to_h
                 typed_methods.merge(
                   fields:      :fields_for,
+                  fields?:     :fields_for?,
                   safe_field:  :safe_add_field,
                   field:       :add_field,
                   proxy_field: :add_proxy_field,
-                  field?:      :has_field?,
+                  import:      :import_into,
+                  import_all:  :import_all_into,
                 )
               end
             end
         end
 
-        def self.extended(other) # :nodoc:
+        def self.extended(other)
           other.extend(WithSchemaFields::ClassMethods)
         end
 
         # A little helper for getting the list of fields of a given type
-        def fields_for(type)
-          public_send("#{type}_fields")
+        def fields_for(type, initialize = nil)
+          if instance_variable_defined?(ivar = :"@#{type}_fields")
+            instance_variable_get(ivar)
+          elsif initialize
+            instance_variable_set(ivar, Concurrent::Map.new)
+          end
+        end
+
+        # Allow hash access with the type or the type and the name
+        def [](type, name = nil)
+          name.nil? ? fields_for(type) : find_field(type, name)
+        end
+
+        # Check if there are fields set fot he given type
+        def fields_for?(type)
+          public_send("#{type}_fields?")
         end
 
         # Return the object name for a given +type+ of list of fields
         def type_name_for(type)
-          SCHEMA_FIELD_TYPES[type]
+          method_name = :"#{type}_type_name"
+          public_send(method_name) if respond_to?(method_name)
         end
 
         # Only add the field if it is not already defined
@@ -88,36 +105,40 @@ module Rails # :nodoc:
         # Add a new field of the give +type+
         # See {OutputField}[rdoc-ref:Rails::GraphQL::OutputField] class.
         def add_field(type, *args, **xargs, &block)
-          xargs[:owner] = self
           klass = Field.const_get(TYPE_FIELD_CLASS[type])
-          object = klass.new(*args, **xargs, &block)
+          object = klass.new(*args, **xargs, owner: self, &block)
 
-          raise DuplicatedError, <<~MSG.squish if has_field?(type, object.name)
+          raise DuplicatedError, (+<<~MSG).squish if has_field?(type, object.name)
             The "#{object.name}" field is already defined on #{type} fields and
             cannot be redefined.
           MSG
 
-          fields_for(type)[object.name] = object
+          fields_for(type, true)[object.name] = object
         rescue DefinitionError => e
-          raise e.class, e.message + "\n  Defined at: #{caller(2)[0]}"
+          raise e.class, +"#{e.message}\n  Defined at: #{caller(2)[0]}"
         end
 
         # Add a new field to the list but use a proxy instead of a hard copy of
         # a given +field+
         def add_proxy_field(type, field, *args, **xargs, &block)
+          field = field.field if field.is_a?(Module) && field <= Alternative::Query
+          raise ArgumentError, (+<<~MSG).squish if field.schema_type != type
+            A #{field.schema_type} field cannot be added as a #{type} field.
+          MSG
+
           klass = Field.const_get(TYPE_FIELD_CLASS[type])
-          raise ArgumentError, <<~MSG.squish unless field.is_a?(klass)
+          raise ArgumentError, (+<<~MSG).squish unless field.is_a?(klass)
             The #{field.class.name} is not a valid field for #{type} fields.
           MSG
 
           xargs[:owner] = self
           object = field.to_proxy(*args, **xargs, &block)
-          raise DuplicatedError, <<~MSG.squish if has_field?(type, object.name)
+          raise DuplicatedError, (+<<~MSG).squish if has_field?(type, object.name)
             The #{field.name.inspect} field is already defined on #{type} fields
             and cannot be replaced.
           MSG
 
-          fields_for(type)[object.name] = object
+          fields_for(type, true)[object.name] = object
         end
 
         # Find a field and then change some flexible attributes of it
@@ -145,6 +166,7 @@ module Rails # :nodoc:
         # Check if a field of the given +type+ exists. The +object+ can be the
         # +gql_name+, +name+, or an actual field.
         def has_field?(type, object)
+          return false unless fields_for?(type)
           object = object.name if object.is_a?(GraphQL::Field)
           fields_for(type).key?(object.is_a?(String) ? object.underscore.to_sym : object)
         end
@@ -152,69 +174,144 @@ module Rails # :nodoc:
         # Find a specific field on the given +type+ list. The +object+ can be
         # the +gql_name+, +name+, or an actual field.
         def find_field(type, object)
+          return unless fields_for?(type)
           object = object.name if object.is_a?(GraphQL::Field)
           fields_for(type)[object.is_a?(String) ? object.underscore.to_sym : object]
         end
 
         # If the field is not found it will raise an exception
         def find_field!(type, object)
-          find_field(type, object) || raise(::ArgumentError, <<~MSG.squish)
+          find_field(type, object) || raise(NotFoundError, (+<<~MSG).squish)
             The #{object.inspect} field on #{type} is not defined yet.
           MSG
         end
 
-        # Get the list of GraphQL names of all the fields difined
+        # Get the list of GraphQL names of all the fields defined
         def field_names_for(type, enabled_only = true)
-          (enabled_only ? fields_for(type).select(&:enabled?) : fields_for(type))
-            .map(&:gql_name).compact
+          source = (enabled_only ? enabled_fields_from(type) : lazy_each_field_from(type))
+          source&.map(&:gql_name)&.eager
+        end
+
+        # Return a lazy enumerator for enabled fields
+        def enabled_fields_from(type)
+          lazy_each_field_from(type)&.select(&:enabled?)
         end
 
         # Run a configuration block for the given +type+
         def configure_fields(type, &block)
-          schema_scoped_config(self, type).instance_exec(&block)
+          WithSchemaFields::ScopedConfig.new(self, type).instance_exec(&block)
+        end
+
+        # Import a class of fields into the given section of schema fields
+        def import_into(type, source)
+          # Import an alternative declaration of a field
+          if source.is_a?(Module) && source <= Alternative::Query
+            return add_proxy_field(type, source.field)
+          end
+
+          case source
+          when Array
+            # Import a list of fields
+            source.each { |field| add_proxy_field(type, field) }
+          when Hash, Concurrent::Map
+            # Import a keyed list of fields
+            source.each_value { |field| add_proxy_field(type, field) }
+          when Helpers::WithFields
+            # Import a set of fields
+            source.fields.each_value { |field| add_proxy_field(type, field) }
+          when Helpers::WithSchemaFields
+            # Import other schema fields
+            (type == :all ? TYPE_FIELD_CLASS.each_key : type.then).each do |import_type|
+              source.fields_for(import_type)&.each_value do |field|
+                add_proxy_field(import_type, field)
+              end
+            end
+          else
+            return if GraphQL.config.silence_import_warnings
+            GraphQL.logger.warn(+"Unable to import #{source.inspect} into #{self.name}.")
+          end
+        end
+
+        # Import a module containing several classes to be imported
+        # TODO: Maybe add deepness into the recursive value
+        def import_all_into(type, mod, recursive: false, **xargs)
+          mod.constants.each do |const_name|
+            object = mod.const_get(const_name)
+
+            import_into(type, object, **xargs) if object.is_a?(Class)
+            import_all_into(type, object, recursive: recursive, **xargs) if recursive && object.is_a?(Module)
+          end
+        end
+
+        # Same as above, but if the name of the module being imported already
+        # dictates the type, skip specifying it
+        def import_all(mod, **xargs)
+          type = mod.name.demodulize.underscore.singularize
+          type = TYPE_FIELD_CLASS.each_key.find { |key| key.to_s == type }
+          return import_all_into(type, mod, **xargs) unless type.nil?
+
+          raise(::ArgumentError, (+<<~MSG).squish)
+            Unable to extract type from #{mod.name}.
+            Please use "import_all_into(_type_, #{mod.name}) instead."
+          MSG
         end
 
         # Validate all the fields to make sure the definition is valid
         def validate!(*)
           super if defined? super
 
-          # TODO: Maybe find a way to freeze the fields, since after validation
-          # the best thing to do is block changes
-          SCHEMA_FIELD_TYPES.each_key do |kind|
-            next unless instance_variable_defined?("@#{kind}_fields")
-            instance_variable_get("@#{kind}_fields")&.each_value(&:validate!)
+          TYPE_FIELD_CLASS.each_key do |type|
+            next unless public_send("#{type}_fields?")
+            fields_for(type).each_value(&:validate!)
           end
         end
 
-        SCHEMA_FIELD_TYPES.each do |kind, type_name|
+        # Find a specific field using its id as +gql_name.type+
+        def find_by_gid(gid)
+          find_field!(gid.scope, gid.name)
+        end
+
+        TYPE_FIELD_CLASS.each_key do |type|
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{kind}_field?(name)
-              has_field?(:#{kind}, name)
+            def #{type}_fields?
+              defined?(@#{type}_fields) && @#{type}_fields.present?
             end
 
-            def #{kind}_field(name)
-              find_field(:#{kind}, name)
+            def #{type}_fields(&block)
+              configure_fields(:#{type}, &block) if block.present?
+              @#{type}_fields if defined?(@#{type}_fields)
             end
 
-            def #{kind}_fields(&block)
-              return @#{kind}_fields ||= Concurrent::Map.new if block.nil?
-              configure_fields(:#{kind}, &block)
-              @#{kind}_fields
+            def add_#{type}_field(*args, **xargs, &block)
+              add_field(:#{type}, *args, **xargs, &block)
             end
 
-            def #{kind}_type_name
-              '#{type_name}'
+            def #{type}_field?(name)
+              has_field?(:#{type}, name)
             end
 
-            def #{kind}_type
+            def #{type}_field(name)
+              find_field(:#{type}, name)
+            end
+
+            def #{type}_type_name
+              source = (respond_to?(:config) ? config : GraphQL.config)
+              source.schema_type_names[:#{type}]
+            end
+
+            def #{type}_type
+              return unless #{type}_fields?
+
               OpenStruct.new(
+                name: "\#{name}[:#{type}]",
                 kind: :object,
                 object?: true,
                 kind_enum: 'OBJECT',
-                fields: defined?(@#{kind}_fields) ? @#{kind}_fields : nil,
-                gql_name: '#{type_name}',
-                interfaces: nil,
+                fields: @#{type}_fields,
+                gql_name: #{type}_type_name,
                 description: nil,
+                output_type?: true,
+                operational?: true,
                 interfaces?: false,
                 internal?: false,
               ).freeze
@@ -224,9 +321,18 @@ module Rails # :nodoc:
 
         protected
 
-          # Create a new instace of the +ScopedConfig+ class
-          def schema_scoped_config(*args)
-            WithSchemaFields::ScopedConfig.new(*args)
+          # A little helper to define arguments using the :arguments key
+          def argument(*args, **xargs, &block)
+            xargs[:owner] = self
+            GraphQL::Argument.new(*args, **xargs, &block)
+          end
+
+          alias arg argument
+
+        private
+
+          def lazy_each_field_from(type)
+            fields_for(type).each_pair.lazy.each_entry.map(&:last) if fields_for?(type)
           end
       end
     end

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Helpers # :nodoc:
+module Rails
+  module GraphQL
+    module Helpers
       # Helper that contains the main exceptions and validation process for a
       # value against a type
       module WithValidator
@@ -22,15 +22,15 @@ module Rails # :nodoc:
             message, idx = result
 
             base_error = idx.present? \
-              ? "#{ordinalize(idx + 1)} value of the #{gql_name} #{type}" \
-              : "#{gql_name} #{type} value"
+              ? +"#{ordinalize(idx + 1)} value of the #{gql_name} #{type}" \
+              : +"#{gql_name} #{type} value"
 
-            raise InvalidValueError, "The #{base_error} #{message}."
+            raise InvalidValueError, +"The #{base_error} #{message}."
           end
 
         private
 
-          def validate_array(value) # :nodoc:
+          def validate_array(value)
             return 'is not an array' unless value.is_a?(Enumerable)
 
             value.each_with_index do |val, idx|
@@ -39,11 +39,11 @@ module Rails # :nodoc:
             end
           end
 
-          def validate_null(value, checker = :null?) # :nodoc:
+          def validate_null(value, checker = :null?)
             'can not be null' if value.nil? && !send(checker)
           end
 
-          def validate_type(value) # :nodoc:
+          def validate_type(value)
             'is invalid' if leaf_type? && !type_klass.valid_output?(value)
           end
       end

data/lib/rails/graphql/helpers.rb

@@ -1,21 +1,28 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Helpers # :nodoc:
+module Rails
+  module GraphQL
+    # All helpers that allow this gem to be flexible and extendable to any other
+    # sources of objects and other gems as well
+    module Helpers
       extend ActiveSupport::Autoload
 
       autoload :AttributeDelegator
       autoload :InheritedCollection
+      autoload :Instantiable
       autoload :LeafFromAr
+      autoload :Unregisterable
       autoload :Registerable
 
       autoload :WithArguments
       autoload :WithAssignment
       autoload :WithCallbacks
       autoload :WithDirectives
+      autoload :WithDescription
       autoload :WithEvents
       autoload :WithFields
+      autoload :WithGlobalID
+      autoload :WithName
       autoload :WithNamespace
       autoload :WithOwner
       autoload :WithSchemaFields

data/lib/rails/graphql/introspection.rb

@@ -1,53 +1,60 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # Module related to some methods regarding the introspection of a schema
     module Introspection
-      module ClassMethods # :nodoc: all
-        def inherited(subclass)
-          super if defined? super
-
-          subclass.query_fields do
-            field(:__schema, '__Schema', null: false) do
-              resolve { schema }
-            end
-
-            field(:__type, '__Type') do
-              argument(:name, :string, null: false)
-              resolve { schema.find_type(argument(:name)) }
-            end
-          end
-        end
-      end
-
-      def self.extended(other) # :nodoc:
-        other.extend(Introspection::ClassMethods)
-      end
-
-      # When register is called, add introspection fields?
+      # When register is called, add introspection related elements
       def register!(*)
         super if defined? super
-        return unless introspection?
-
-        Helpers::WithSchemaFields::SCHEMA_FIELD_TYPES.each do |type, name|
-          GraphQL.type_map.register_alias(name, namespace: namespace) do
-            result = public_send("#{type}_type")
-            type.eql?(:query) || result.fields.present? ? result : nil
+        enable_introspection! if !introspection? && config.enable_introspection
+
+        # Although this is not necessary besides for introspection, there is no
+        # real disadvantage on adding it
+        Helpers::WithSchemaFields::TYPE_FIELD_CLASS.each_key do |type|
+          GraphQL.type_map.register_alias(type_name_for(type), namespace: namespace) do
+            result = public_send(:"#{type}_type")
+            type.eql?(:query) || result.present? ? result : nil
           end
         end
       end
 
       # Check if the schema has introspection enabled
       def introspection?
-        true
+        false
       end
 
-      # Remove introspection fields and disable introspection
-      def disable_introspection!
-        disable_fields(:query, :__schema, :__type)
-        redefine_singleton_method(:introspection?) { false }
-      end
+      protected
+
+        # Enable introspection fields
+        def enable_introspection!
+          redefine_singleton_method(:introspection?) { true }
+          introspection_dependencies!
+
+          safe_add_field(:query, :__schema, '__Schema', null: false) do
+            resolve { schema }
+          end
+
+          safe_add_field(:query, :__type, '__Type') do
+            argument(:name, :string, null: false)
+            resolve { schema.find_type(argument(:name)) }
+          end
+        end
+
+        # Add the introspection dependencies, but only when necessary
+        def introspection_dependencies!
+          GraphQL.type_map.add_dependencies([
+            "#{__dir__}/type/enum/directive_location_enum",
+            "#{__dir__}/type/enum/type_kind_enum",
+
+            "#{__dir__}/type/object/directive_object",
+            "#{__dir__}/type/object/enum_value_object",
+            "#{__dir__}/type/object/field_object",
+            "#{__dir__}/type/object/input_value_object",
+            "#{__dir__}/type/object/schema_object",
+            "#{__dir__}/type/object/type_object",
+          ], to: :base)
+        end
     end
   end
 end