rails-graphql 1.0.0.beta → 1.0.0.rc2

data/lib/rails/graphql/request.rb

@@ -70,8 +70,11 @@ module Rails
       alias channel origin
 
       delegate :action_name, to: :controller, allow_nil: true
+      delegate :find_type!, to: :strategy, allow_nil: true
       delegate :all_listeners, :all_events, to: :schema
 
+      alias find_type find_type!
+
       class << self
         # Shortcut for initialize, set context, and execute
         def execute(*args, schema: nil, namespace: :base, context: {}, **xargs)
@@ -92,12 +95,12 @@ module Rails
 
         # Allow accessing component-based objects through the request
         def const_defined?(name, *)
-          Component.const_defined?(name) || super
+          Component.const_defined?(name, false) || super
         end
 
         # Allow accessing component-based objects through the request
         def const_missing(name)
-          Component.const_defined?(name) ? Component.const_get(name) : super
+          Component.const_defined?(name, false) ? Component.const_get(name, false) : super
         end
       end
 
@@ -105,8 +108,6 @@ module Rails
       def initialize(schema = nil, namespace: :base)
         @namespace = schema&.namespace || namespace
         @schema = GraphQL::Schema.find!(@namespace)
-        @prepared_data = {}
-        @extensions = {}
 
         ensure_schema!
       end
@@ -126,6 +127,11 @@ module Rails
         @context = build_ostruct(data).freeze
       end
 
+      # Allow adding extra information to the response, in a extensions key
+      def extensions
+        @extensions ||= {}
+      end
+
       # Execute a given document with the given arguments
       def execute(document, **xargs)
         output = xargs.delete(:as) || schema.config.default_response_format
@@ -134,14 +140,15 @@ module Rails
 
         document, cache = nil, document if xargs.delete(:compiled)
         prepared_data = xargs.delete(:data_for)
-
         reset!(**xargs)
-        prepared_data&.each { |key, value| prepare_data_for(key, value) }
+
         @response = initialize_response(output, formatter)
+        import_prepared_data(prepared_data)
         execute!(document, cache)
 
         response.public_send(formatter)
       rescue StaticResponse
+        # TODO: Maybe change this to a throw/catch instead
         response.public_send(formatter)
       end
 
@@ -178,31 +185,43 @@ module Rails
       # This is used by cache and static responses to jump from executing to
       # delivery a response right away
       def force_response(response, error = StaticResponse)
+        return unless defined?(@response)
         @response = response
         raise error
       end
 
+      # Import prepared data that is formatted as a hash
+      def import_prepared_data(prepared_data)
+        prepared_data&.each do |key, value|
+          prepare_data_for(key, value)
+        end
+      end
+
       # Add a new prepared data from +value+ to the given +field+
       def prepare_data_for(field, value, **options)
         field = PreparedData.lookup(self, field)
 
-        if @prepared_data.key?(field)
-          @prepared_data[field].push(value)
+        if prepared_data.key?(field)
+          prepared_data[field].push(value)
         else
-          @prepared_data[field] = PreparedData.new(field, value, **options)
+          prepared_data[field] = PreparedData.new(field, value, **options)
         end
       end
 
       # Recover the next prepared data for the given field
       def prepared_data_for(field)
+        return unless defined?(@prepared_data)
+
         field = field.field if field.is_a?(Component::Field)
-        @prepared_data[field]
+        prepared_data[field]
       end
 
       # Check if the given field has prepared data
       def prepared_data_for?(field)
+        return false unless defined?(@prepared_data)
+
         field = field.field if field.is_a?(Component::Field)
-        defined?(@prepared_data) && @prepared_data.key?(field)
+        prepared_data.key?(field)
       end
 
       # Build a easy-to-access object representing the current information of
@@ -231,7 +250,7 @@ module Rails
 
       # A little helper to report an error on a given node
       def report_node_error(message, node, **xargs)
-        xargs[:locations] ||= location_of(node) unless xargs.key?(:line)
+        xargs[:locations] ||= location_of(node)
         report_error(message, **xargs)
       end
 
@@ -251,8 +270,7 @@ module Rails
         xargs[:path] ||= stack_to_path
         errors.add(message, **xargs)
 
-        # Return nil for easier usage
-        nil
+        nil # Return nil for easier usage
       end
 
       # Add the given +object+ into the execution +stack+ and execute the given
@@ -271,25 +289,25 @@ module Rails
         end.compact.reverse
       end
 
-      # Add extensions to the request, which ensures a bunch of extended
-      # behaviors for all the objects created through the request
+      # Add class extensions to the request, which ensures a bunch of
+      # extended behaviors for all the objects created through the request
       def extend(*modules)
-        import_extensions(*modules)
-        request_ext = extensions[self.class]
+        import_class_extensions(*modules)
+        request_ext = class_extensions[self.class]
         super(request_ext) if request_ext && !is_a?(request_ext)
       end
 
-      # This initiates a new object which is aware of extensions
+      # This initiates a new object which is aware of class extensions
       def build(klass, *args, &block)
-        ext_module = extensions[klass]
+        ext_module = class_extensions[klass]
         obj = klass.new(*args, &block)
         obj.extend(ext_module) if ext_module
         obj
       end
 
-      # This allocates a new object which is aware of extensions
+      # This allocates a new object which is aware of class extensions
       def build_from_cache(klass)
-        ext_module = extensions[klass]
+        ext_module = class_extensions[klass]
         obj = klass.allocate
         obj.extend(ext_module) if ext_module
         obj
@@ -349,6 +367,7 @@ module Rails
         resolve_from_cache = (version == schema.version)
 
         # Run the document from scratch if TypeMap has changed
+        # TODO: We need to save the new organized document
         return run_document unless resolve_from_cache
         @valid_cache = true unless defined?(@valid_cache)
 
@@ -360,9 +379,19 @@ module Rails
         @strategy.resolve!
       end
 
-      private
+      protected
 
-        attr_reader :extensions
+        # Stores all the class extensions
+        def class_extensions
+          @class_extensions ||= {}
+        end
+
+        # Stores all the prepared data, but only when it is needed
+        def prepared_data
+          @prepared_data ||= {}
+        end
+
+      private
 
         # Reset principal variables and set the given +args+
         def reset!(args: nil, variables: {}, operation_name: nil, origin: nil)
@@ -382,8 +411,6 @@ module Rails
           @stack      = [schema]
           @cache      = {}
           @log_extra  = {}
-          @fragments  = {}
-          @operations = {}
           @subscriptions = {}
           @used_variables = Set.new
 
@@ -401,14 +428,18 @@ module Rails
         ensure
           report_unused_variables
           write_cache_request(cache) if cache.present? && !valid_cache?
+          @response.try(:append_errors, errors)
+
+          if defined?(@extensions)
+            @response.try(:append_extensions, @extensions)
+            @extensions.clear
+          end
 
           @cache.clear
           @strategy&.clear
           @fragments&.clear
-          @operations.clear
-          @prepared_data.clear
-
-          @response.try(:append_errors, errors)
+          @operations&.clear
+          @prepared_data&.clear
         end
 
         # Prepare the definitions, find the strategy and resolve
@@ -416,9 +447,8 @@ module Rails
           return if @document.nil?
 
           collect_definitions!
-
           @strategy ||= find_strategy!
-          @strategy.trigger_event(:request)
+          @strategy.trigger_event(:request) if with == :resolve!
           @strategy.public_send(with)
         end
 
@@ -440,26 +470,26 @@ module Rails
           build(klass, self)
         end
 
-        # Find all necessary extensions inside the given +modules+ and prepare
-        # the extension base module
-        def import_extensions(*modules)
+        # Find all necessary class extensions inside the given +modules+
+        # and prepare the extension base module
+        def import_class_extensions(*modules)
           modules.each do |mod|
             mod.constants.each do |const_name|
               const_name = const_name.to_s
-              const = mod.const_get(const_name)
+              const = mod.const_get(const_name, false)
               next unless const.is_a?(Module)
 
               # Find the related request class to extend
               klass = const_name === 'Request' ? self.class : begin
                 const_name.split('_').inject(self.class) do |k, next_const|
-                  k.const_defined?(next_const) ? k.const_get(next_const) : break
+                  k.const_defined?(next_const) ? k.const_get(next_const, false) : break
                 end
               end
 
-              # Create the shared module and include the extension
+              # Create the shared module and include the class extension
               next unless klass&.is_a?(Class)
-              extensions[klass] ||= Module.new
-              extensions[klass].include(const)
+              class_extensions[klass] ||= Module.new
+              class_extensions[klass].include(const)
             end
           end
         end
@@ -477,7 +507,7 @@ module Rails
         # Build the payload to be sent to the log
         def log_payload(data)
           name = @operation_name.presence
-          name ||= operations.keys.first if operations.size.eql?(1)
+          name ||= operations.keys.first if operations&.size&.eql?(1)
           map_variables = args.to_h.transform_keys do |key|
             @arg_names[key.to_s]
           end

data/lib/rails/graphql/schema.rb

@@ -57,7 +57,7 @@ module Rails
         # :singleton-method:
         # Since there are only one schema per namespace, the name is constant
         def gql_name
-          'schema'
+          '__Schema'
         end
 
         alias graphql_name gql_name
@@ -136,21 +136,6 @@ module Rails
           namespace
         end
 
-        # Return the subscription provider for the current schema
-        def subscription_provider
-          if !defined?(@subscription_provider)
-            @subscription_provider = config.default_subscription_provider
-            subscription_provider
-          elsif @subscription_provider.is_a?(String)
-            provider = (name = @subscription_provider).safe_constantize
-            return @subscription_provider = provider.new(logger: logger) unless provider.nil?
-
-            raise ::NameError, +"uninitialized constant #{name}"
-          else
-            @subscription_provider
-          end
-        end
-
         # Check if the schema is valid
         def valid?
           defined?(@validated) && @validated
@@ -221,6 +206,35 @@ module Rails
           type_map.fetch!(directive, **xargs)
         end
 
+        # See {Request}[rdoc-ref:Rails::GraphQL::Request]
+        def request
+          return if self == ::Rails::GraphQL::Schema
+          Rails::GraphQL::Request.new(self)
+        end
+
+        # See {Request}[rdoc-ref:Rails::GraphQL::Request]
+        def execute(*args, **xargs)
+          return if self == ::Rails::GraphQL::Schema
+          Rails::GraphQL::Request.execute(*args, **xargs, schema: self)
+        end
+
+        alias perform execute
+
+        # Return the subscription provider for the current schema
+        def subscription_provider
+          if !defined?(@subscription_provider)
+            @subscription_provider = config.subscription_provider || config.default_subscription_provider
+            subscription_provider
+          elsif @subscription_provider.is_a?(String)
+            provider = (name = @subscription_provider).safe_constantize
+            return @subscription_provider = provider.new(logger: logger) unless provider.nil?
+
+            raise ::NameError, +"uninitialized constant #{name}"
+          else
+            @subscription_provider
+          end
+        end
+
         # Remove subscriptions by their provided +sids+
         def remove_subscriptions(*sids)
           subscription_provider&.remove(*sids)
@@ -286,12 +300,10 @@ module Rails
         end
 
         protected
-
           attr_writer :subscription_provider
 
           # Mark the given class to be pending of registration
           def inherited(subclass)
-            subclass.spec_object = false
             subclass.abstract = false
             super if defined? super
 
@@ -301,6 +313,11 @@ module Rails
             end
           end
 
+          # Syntax sugar for beginners
+          def field(*args, **xargs, &block)
+            add_field(:query, *args, **xargs, &block)
+          end
+
           # Indicate to type map that the current schema depends on all the
           # files in the provided +path+ directory
           def load_directory(dir = '.', recursive: true)
@@ -376,20 +393,9 @@ module Rails
             superclass ||= GraphQL::Source.find_for!(object)
 
             xargs[:suffix] = 'Source'
-            create_and_build = build
-            schema_namespace = namespace
-
-            create_klass(object, superclass, GraphQL::Source, **xargs) do
-              set_namespace schema_namespace
-
-              xargs.each do |key, value|
-                _, segment = key.to_s.split('skip_on_')
-                skip_on segment, value if segment.present?
-              end
+            xargs[:build] = build
 
-              instance_exec(&block) if block.present?
-              build_all if create_and_build
-            end
+            create_type(object, superclass, **xargs, &block)
           end
 
           # Helper method to create multiple sources with the same type
@@ -402,61 +408,8 @@ module Rails
 
           # A simpler way to create a new type object without having to create
           # a class in a different file
-          def create_type(name, superclass, **xargs, &block)
-            superclass = GraphQL::Type.const_get(superclass) unless superclass.is_a?(Module)
-            xargs[:suffix] ||= superclass.base_type.name.demodulize
-
-            create_klass(name, superclass, GraphQL::Type, **xargs, &block)
-          end
-
-        private
-
-          # Helper to create objects that are actually classes of a given
-          # +superclass+ ensuring that it inherits from +base_class+.
-          #
-          # The +suffix+ option can ensures that the name of the created
-          # class ends with a specific suffix.
-          def create_klass(name_or_object, superclass, base_class = nil, **xargs, &block)
-            name = name_or_object.is_a?(Module) ? name_or_object.name : name_or_object.to_s
-
-            base_module = name.classify.deconstantize
-            base_module.prepend('GraphQL::') unless base_module =~ /^GraphQL(::|$)/
-            base_module = base_module.delete_suffix('::').constantize
-
-            klass_name = name.classify.demodulize
-            klass_name += xargs[:suffix] if xargs.key?(:suffix) &&
-              !klass_name.end_with?(xargs[:suffix])
-
-            if base_module.const_defined?(klass_name)
-              klass = base_module.const_get(klass_name)
-
-              raise DuplicatedError, (+<<~MSG).squish unless !xargs[:once] && klass < superclass
-                A constant named "#{klass_name}" already exists for the
-                "#{base_module.name}" module.
-              MSG
-
-              # This likely happened because the classes are being reloaded, so
-              # call inherited again as if the class has just been created
-              superclass.inherited(klass)
-            else
-              base_class ||= superclass.ancestors.find { |k| k.superclass === Class }
-
-              valid = superclass.is_a?(Module) && superclass < base_class
-              raise DefinitionError, (+<<~MSG).squish unless valid
-                The given "#{superclass}" superclass does not inherites from
-                #{base_class.name} class.
-              MSG
-
-              klass = base_module.const_set(klass_name, Class.new(superclass))
-            end
-
-            klass.abstract = xargs[:abstract] if xargs.key?(:abstract)
-            klass.assigned_to = name_or_object if name_or_object.is_a?(Module) &&
-              klass.is_a?(Helpers::WithAssignment)
-
-            klass.set_namespace(namespace)
-            klass.module_exec(&block) if block.present?
-            klass
+          def create_type(*args, **xargs, &block)
+            GraphQL::Type.create!(self, *args, **xargs, &block)
           end
       end
     end

data/lib/rails/graphql/shortcuts.rb

@@ -2,23 +2,31 @@
 
 # This exposed module allows some shortcuts while working outside of the gem
 module GraphQL
+  autoload :BaseController, "#{__dir__}/railties/app/base_controller.rb"
+  autoload :BaseChannel,    "#{__dir__}/railties/app/base_channel.rb"
+
   # List of constant shortcuts, as string to not trigger autoload
   CONST_SHORTCUTS = {
     CacheKey:           '::Rails::GraphQL::CacheKey',
     Channel:            '::Rails::GraphQL::Channel',
     Controller:         '::Rails::GraphQL::Controller',
     Directive:          '::Rails::GraphQL::Directive',
-    Field:              '::Rails::GraphQL::Field',
     GlobalID:           '::Rails::GraphQL::GlobalID',
     Request:            '::Rails::GraphQL::Request',
     Schema:             '::Rails::GraphQL::Schema',
     Source:             '::Rails::GraphQL::Source',
     Type:               '::Rails::GraphQL::Type',
 
+    Field:              '::Rails::GraphQL::Alternative::Field',
     Query:              '::Rails::GraphQL::Alternative::Query',
     Mutation:           '::Rails::GraphQL::Alternative::Mutation',
     Subscription:       '::Rails::GraphQL::Alternative::Subscription',
 
+    FieldSet:           '::Rails::GraphQL::Alternative::FieldSet',
+    QuerySet:           '::Rails::GraphQL::Alternative::QuerySet',
+    MutationSet:        '::Rails::GraphQL::Alternative::MutationSet',
+    SubscriptionSet:    '::Rails::GraphQL::Alternative::SubscriptionSet',
+
     Enum:               '::Rails::GraphQL::Type::Enum',
     Input:              '::Rails::GraphQL::Type::Input',
     Interface:          '::Rails::GraphQL::Type::Interface',
@@ -26,9 +34,6 @@ module GraphQL
     Scalar:             '::Rails::GraphQL::Type::Scalar',
     Union:              '::Rails::GraphQL::Type::Union',
 
-    ProxyField:         '::Rails::GraphQL::Field::ProxyField',
-    AssociationField:   '::Rails::GraphQL::Field::AssociationField',
-
     BaseSource:         '::Rails::GraphQL::Source::BaseSource',
     ActiveRecordSource: '::Rails::GraphQL::Source::ActiveRecordSource',
   }.freeze
@@ -43,7 +48,8 @@ module GraphQL
   #
   #   Rails::GraphQL::Directive::DeprecatedDirective(...)
   #   # => Rails::GraphQL::Directive::DeprecatedDirective.new(...)
-  DIRECTIVE_SHORTCUTS = %i[DeprecatedDirective IncludeDirective SkipDirective].freeze
+  DIRECTIVE_SHORTCUTS = %i[DeprecatedDirective IncludeDirective SkipDirective
+    SpecifiedByDirective].freeze
 
   class << self
     delegate *DIRECTIVE_SHORTCUTS, to: 'Rails::GraphQL::Directive'

data/lib/rails/graphql/source/active_record/builders.rb

@@ -4,11 +4,6 @@ module Rails
   module GraphQL
     # All the helper methods for building the source
     module Source::ActiveRecordSource::Builders
-      # Override the object class to identify interfaces due to STI
-      def object_class
-        sti_interface? ? interface_class : super
-      end
-
       # List of all columns that should be threated as IDs
       # TODO: Add a exclusive cache for the build process
       def id_columns
@@ -62,9 +57,7 @@ module Rails
         # Check if the given model is consider an interface due to single table
         # inheritance and the given model is the base class
         def sti_interface?
-          @sti_interface ||= begin
-            model.has_attribute?(model.inheritance_column) && model.base_class == model
-          end
+          model.has_attribute?(model.inheritance_column) && model.base_class == model
         end
 
         # Build all enums associated to the class, collecting them from the
@@ -73,8 +66,8 @@ module Rails
           return remove_instance_variable(:@enums) if enums.blank?
 
           @enums = enums.each_with_object({}) do |(attribute, setting), hash|
-            class_name = base_name + attribute.to_s.classify
-            hash[attribute.to_s] = create_enum(class_name, setting, once: true)
+            class_name = base_name.tr('_', '') + attribute.to_s.classify
+            hash[attribute.to_s] = create_enum(class_name, setting)
           rescue DuplicatedError
             next
           end.freeze
@@ -82,15 +75,14 @@ module Rails
 
         # Build all necessary attribute fields into the given +holder+
         def build_attribute_fields(holder, **field_options)
-          each_attribute(holder) do |key, type, **options|
-            next if holder.field?(key) || skip_field?(key, on: holder.kind)
 
+          each_attribute(holder) do |key, type, **options|
             str_key = key.to_s
             type = (defined?(@enums) && @enums.key?(str_key) && @enums[str_key]) ||
               (id_columns.include?(str_key) && :id) || type
 
             options[:null] = !attr_required?(key) unless options.key?(:null)
-            holder.field(key, type, **options.merge(field_options[key] || {}))
+            holder.safe_field(key, type, **options.merge(field_options[key] || {}))
           end
         end
 
@@ -99,20 +91,22 @@ module Rails
           return unless with_associations?
 
           each_reflection do |item|
-            next if holder.field?(item.name) || item.polymorphic? ||
+            next if holder.has_field?(item.name) || item.polymorphic? ||
               skip_field?(item.name, on: holder.kind)
 
             type_map_after_register(item.klass) do |type|
-              next unless (type.object? && type.try(:assigned_to) != item.klass) ||
-                type.interface?
+              next unless type.try(:assigned_to) != item.klass ||
+                type.input_type? || type.leaf_type?
 
               options = reflection_to_options(item)
 
-              if type <= Source::Base
-                source_name = item.collection? ? type.plural : type.singular
-                proxy_options = options.merge(alias: reflection.name, of_type: :proxy)
+              if item.collection?
+                owner = type.try(:owner)
+                source = owner.is_a?(Helpers::WithSchemaFields) &&
+                  (owner.try(:collection_field) || owner.query_fields.try(:[], item.name))
 
-                if (source = type.query_fields[source_name]).present?
+                if source.present?
+                  proxy_options = options.merge(alias: item.name, of_type: :proxy)
                   field = holder.safe_field(source, **proxy_options)
                 end
               end
@@ -130,16 +124,20 @@ module Rails
         def build_reflection_inputs(holder)
           return unless with_associations?
 
+          suffix = GraphQL.config.auto_suffix_input_objects
           model.nested_attributes_options.each_key do |reflection_name|
-            next if (reflection = model._reflect_on_association(reflection_name)).nil?
+            reflection = model._reflect_on_association(reflection_name)
+            next if reflection.nil? || reflection.polymorphic?
 
             expected_name = reflection.klass.name.tr(':', '')
-            expected_name += 'Input' unless expected_name.end_with?('Input')
+            expected_name += suffix unless expected_name.end_with?(suffix)
+
+            type_map_after_register(expected_name) do |type|
+              next unless type.input?
 
-            type_map_after_register(expected_name) do |input|
               options = reflection_to_options(reflection).merge(null: true)
               field_name = "#{reflection.name}_attributes"
-              holder.safe_field(field_name, input, **options)
+              holder.safe_field(field_name, type, **options)
             end
           end
         end