rails-graphql 0.2.0 → 1.0.0.beta

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

@@ -1,27 +1,23 @@
 # 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|
+            TYPE_FIELD_CLASS.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) }
@@ -29,7 +25,8 @@ module Rails # :nodoc:
           end
         end
 
-        ScopedConfig = Struct.new(:source, :type) do # :nodoc: all
+        # Helper class to be used as the +self+ in configuration blocks
+        ScopedConfig = Struct.new(:source, :type) do
           def arg(*args, **xargs, &block)
             xargs[:owner] ||= source
             GraphQL::Argument.new(*args, **xargs, &block)
@@ -54,27 +51,42 @@ 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
 
+        # Check if there are fields set fot he given type
+        def fields_for?(type)
+          public_send("#{type}_fields?")
+        end
+
+        alias [] :fields_for
+
         # 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 +100,39 @@ 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)
+          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 +160,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,41 +168,103 @@ 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
         def field_names_for(type, enabled_only = true)
-          (enabled_only ? fields_for(type).select(&:enabled?) : fields_for(type))
-            .map(&:gql_name).compact
+          return unless fields_for?(type)
+          list = fields_for(type)
+          list = list.select(&:enabled?) if enabled_only
+          list.map(&:gql_name).compact
         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)
+          return if source.try(:abstract?)
+
+          # 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
+          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 |kind|
+            next unless public_send("#{kind}_fields?")
+            fields_for(kind).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 |kind|
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{kind}_field?(name)
               has_field?(:#{kind}, name)
@@ -196,38 +274,42 @@ module Rails # :nodoc:
               find_field(:#{kind}, name)
             end
 
+            def add_#{kind}_field(*args, **xargs, &block)
+              add_field(:#{kind}, *args, **xargs, &block)
+            end
+
+            def #{kind}_fields?
+              defined?(@#{kind}_fields) && @#{kind}_fields.present?
+            end
+
             def #{kind}_fields(&block)
-              return @#{kind}_fields ||= Concurrent::Map.new if block.nil?
-              configure_fields(:#{kind}, &block)
-              @#{kind}_fields
+              configure_fields(:#{kind}, &block) if block.present?
+              @#{kind}_fields if defined?(@#{kind}_fields)
             end
 
             def #{kind}_type_name
-              '#{type_name}'
+              source = (respond_to?(:config) ? config : GraphQL.config)
+              source.schema_type_names[:#{kind}]
             end
 
             def #{kind}_type
-              OpenStruct.new(
-                kind: :object,
-                object?: true,
-                kind_enum: 'OBJECT',
-                fields: defined?(@#{kind}_fields) ? @#{kind}_fields : nil,
-                gql_name: '#{type_name}',
-                interfaces: nil,
-                description: nil,
-                interfaces?: false,
-                internal?: false,
-              ).freeze
+              if defined?(@#{kind}_fields) && @#{kind}_fields.present?
+                OpenStruct.new(
+                  name: "\#{name}[:#{kind}]",
+                  kind: :object,
+                  object?: true,
+                  kind_enum: 'OBJECT',
+                  fields: @#{kind}_fields,
+                  gql_name: #{kind}_type_name,
+                  interfaces: nil,
+                  description: nil,
+                  interfaces?: false,
+                  internal?: false,
+                ).freeze
+              end
             end
           RUBY
         end
-
-        protected
-
-          # Create a new instace of the +ScopedConfig+ class
-          def schema_scoped_config(*args)
-            WithSchemaFields::ScopedConfig.new(*args)
-          end
       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
+
+        # Enaqble 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

data/lib/rails/graphql/railtie.rb

@@ -4,8 +4,8 @@ require 'rails/railtie'
 require 'action_controller'
 require 'action_controller/railtie'
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = Rails GraphQL Railtie
     #
     # Rails integration and configuration
@@ -21,19 +21,43 @@ module Rails # :nodoc:
         require_relative './schema'
       end
 
+      console do
+        config.graphql.enable_string_collector = false
+        config.graphql.default_response_format = :hash
+      end
+
       # Ensure a valid logger
-      initializer 'graphql.logger' do
+      initializer 'graphql.logger' do |app|
         ActiveSupport.on_load(:graphql) do
           return if config.logger.present?
-          if ::Rails.logger.respond_to?(:tagged)
-            config.logger = ::Rails.logger
+
+          logger = ::Rails.logger
+          if logger.respond_to?(:tagged)
+            config.logger = logger
           else
-            config.logger = ActiveSupport::TaggedLogging.new(::Rails.logger)
+            config.logger = ActiveSupport::TaggedLogging.new(logger)
+          end
+        end
+      end
+
+      initializer 'graphql.active_record_backtrace_print' do
+        if defined?(ActiveRecord)
+          base = Module.new
+          base.send(:define_method, :to_gql_backtrace) do
+            +"#<#{self.class.name} id: #{id}>"
           end
+
+          relation = Module.new
+          relation.send(:define_method, :to_gql_backtrace) do
+            +"[#<#{model.name}>](#{size})"
+          end
+
+          ActiveRecord::Base.include(base)
+          ActiveRecord::Relation.include(relation)
         end
       end
 
-      # Expose database runtime to controller for logging.
+      # Expose GraphQL runtime to controller for logging
       initializer 'graphql.log_runtime' do
         require_relative './railties/controller_runtime'
         ActiveSupport.on_load(:action_controller) do
@@ -41,45 +65,76 @@ module Rails # :nodoc:
         end
       end
 
+      # Clean up GraphQL params from logger
+      initializer 'graphql.params_cleanup' do
+        key = 'start_processing.action_controller'
+        ActiveSupport::Notifications.subscribe(key) do |*, payload|
+          payload[:params].except!(*config.graphql.omit_parameters) \
+            if payload[:headers]['action_controller.instance'].is_a?(GraphQL::Controller)
+        end
+      end
+
+      # Copy filter params when they are not exclusively set for GraphQL
+      initializer 'graphql.params_filter' do |app|
+        config.after_initialize do
+          config.graphql.filter_parameters ||= app.config.filter_parameters
+        end
+      end
+
       # Backtrace cleaner for removing gem paths
       initializer 'graphql.backtrace_cleaner' do
         require_relative './railties/log_subscriber'
         ActiveSupport.on_load(:graphql) do
-          GraphQL::LogSubscriber.backtrace_cleaner = ::Rails.backtrace_cleaner
+          LogSubscriber.backtrace_cleaner = ::Rails.backtrace_cleaner
         end
       end
 
-      # Add reloader ability for files under 'app/graphql'
-      # TODO: Maybe improve to use rails auto loader
-      initializer 'graphql.reloader' do
-        Rails::GraphQL.eager_load!
-        ActiveSupport::Reloader.to_prepare do
-          Rails::GraphQL.type_map.use_checkpoint!
-          Rails::GraphQL.reload_ar_adapters!
-
-          Object.send(:remove_const, :GraphQL) if Object.const_defined?(:GraphQL)
+      # Add the GraphQL Global ID serializer to active job serializers
+      initializer 'graphql.global_id' do
+        ActiveSupport.on_load(:active_job) do
+          ActiveJob::Serializers.add_serializers(Rails::GraphQL::GlobalID::Serializer)
+        end
+      end
 
-          load "#{__dir__}/shortcuts.rb"
+      # Simply switch to hash output if rails is running on test mode
+      initializer 'graphql.tests' do
+        if Rails.env.test?
+          config.graphql.enable_string_collector = false
+          config.graphql.default_response_format = :hash
+        end
+      end
 
-          $LOAD_PATH.each do |path|
-            next unless path =~ %r{\/app\/graphql$}
-            Dir.glob("#{path}/**/*.rb").sort.each(&method(:load))
+      # Set GraphQL cache store same as rails default cache store, unless the
+      # default value is a Null Cache, then use the fallback instead
+      initializer 'graphql.cache', after: :initialize_cache do
+        config.graphql.cache ||= begin
+          if !::Rails.cache.is_a?(::ActiveSupport::Cache::NullStore)
+            ::Rails.cache
+          elsif config.graphql.cache_fallback.is_a?(Proc)
+            config.graphql.cache_fallback.call
+          else
+            config.graphql.cache_fallback
           end
-
-          GraphQL::Source.send(:build_pending!)
         end
       end
 
-      # initializer "active_record.set_reloader_hooks" do
-      #   ActiveSupport.on_load(:active_record) do
-      #     ActiveSupport::Reloader.before_class_unload do
-      #       if ActiveRecord::Base.connected?
-      #         ActiveRecord::Base.clear_cache!
-      #         ActiveRecord::Base.clear_reloadable_connections!
-      #       end
-      #     end
-      #   end
-      # end
+      # Properly setup how GraphQL reload itself
+      # TODO: Check proper support for Rails engines
+      initializer 'graphql.reloader', before: :load_config_initializers do |app|
+        next unless (path = app.root.join('app', 'graphql')).exist?
+
+        children = config.graphql.paths.join(',')
+        autoloader = app.autoloaders.main
+
+        ActiveSupport::Dependencies.autoload_paths.delete(path.to_s)
+        autoloader.collapse(path.glob("**/{#{children}}").select(&:directory?))
+        autoloader.push_dir(path, namespace: ::GraphQL)
+        config.watchable_dirs[path.to_s] = [:rb]
+
+        autoloader.on_unload do |_, value, _|
+          value.unregister! if value.is_a?(Helpers::Unregisterable)
+        end
+      end
     end
   end
 end