rails-graphql 0.2.1 → 1.0.0.beta

data/lib/rails/graphql/schema.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = GraphQL Schema
     #
     # This is a pure representation of a GraphQL schema.
@@ -11,7 +11,7 @@ module Rails # :nodoc:
     # namespaces, where each schema is associated with one and only one
     # namespace, guiding requests and types searching.
     #
-    # This class works similary to the {TypeMap}[rdoc-ref:Rails::base_classMap]
+    # This class works similarly to the {TypeMap}[rdoc-ref:Rails::base_classMap]
     # class, where its purpose is to know which QueryFields, Mutations, and
     # Subscriptions are available. The main difference is that it doesn't hold
     # namespace-based objects, since each schema is associated to a single
@@ -19,17 +19,13 @@ module Rails # :nodoc:
     class Schema
       extend Helpers::WithSchemaFields
       extend Helpers::WithDirectives
+      extend Helpers::WithGlobalID
       extend Helpers::Registerable
       extend GraphQL::Introspection
 
       include ActiveSupport::Configurable
       include ActiveSupport::Rescuable
-
-      # The purpose of instantiating an schema is to have access to its
-      # public methods. It then runs from the strategy perspective, pointing
-      # out any other methods to the manually set event
-      delegate_missing_to :event
-      attr_reader :event
+      include Helpers::Instantiable
 
       self.abstract = true
       self.spec_object = true
@@ -37,20 +33,26 @@ module Rails # :nodoc:
 
       # Imports schema specific configurations
       configure do |config|
-        %i[enable_string_collector request_strategies].each do |name|
-          config.send("#{name}=", GraphQL.config.send(name))
+        inherited_keys = %i[
+          enable_introspection request_strategies
+          enable_string_collector default_response_format
+          schema_type_names cache
+          default_subscription_provider default_subscription_broadcastable
+        ].to_set
+
+        config.default_proc = proc do |hash, key|
+          hash[key] = GraphQL.config.send(key) if inherited_keys.include?(key)
         end
       end
 
+      rescue_from(PersistedQueryNotFound) do |error|
+        response = { errors: [{ message: +'PersistedQueryNotFound' }] }
+        error.request.force_response(response, error)
+      end
+
       class << self
         delegate :type_map, :logger, to: '::Rails::GraphQL'
-
-        # Mark the given class to be pending of registration
-        def inherited(subclass)
-          subclass.spec_object = false
-          subclass.abstract = false
-          super if defined? super
-        end
+        delegate :version, to: :type_map
 
         # :singleton-method:
         # Since there are only one schema per namespace, the name is constant
@@ -63,7 +65,7 @@ module Rails # :nodoc:
         # :singleton-method:
         # Since there is only one schema per namespace, then both kind and
         # to_sym, which is used to register, are the same
-        def kind # :nodoc:
+        def kind
           :schema
         end
 
@@ -90,9 +92,18 @@ module Rails # :nodoc:
         end
 
         # :singleton-method:
-        # For campatibility with type map
-        def eager_load!
-          TypeMap.loaded! :Schema
+        # The base class of all schemas is always +Schema+
+        def gid_base_class
+          Schema
+        end
+
+        # :singleton-method:
+        # Return the schema
+        def find_by_gid(gid)
+          result = find!(gid.namespace.to_sym)
+          return result if gid.name.nil?
+
+          result.find_field!(gid.scope, gid.name)
         end
 
         # Find all types that are available for the current schema
@@ -100,17 +111,66 @@ module Rails # :nodoc:
           type_map.each_from(namespace, base_class: base_class, &block)
         end
 
-        # Schemas are assigned to a single namespace
-        def set_namespace(*list)
-          super(list.first)
+        # Schemas are assigned to a single namespace. You can provide a module
+        # as the second argument to associate that module to the same namespace
+        def set_namespace(ns, mod = nil)
+          @namespace = normalize_namespaces([ns]).first
+          type_map.associate(@namespace, mod) if mod.is_a?(Module)
         end
 
+        alias set_namespaces set_namespace
+
         # Schemas are assigned to a single namespace and not inherited
-        def namespace(*list)
-          list.blank? ? (namespaces.first || :base) : set_namespace(*list)
+        def namespace(*args)
+          if args.present?
+            set_namespace(*args)
+          elsif defined?(@namespace) && !@namespace.nil?
+            @namespace
+          else
+            :base
+          end
+        end
+
+        # Add compatibility to the list of namespaces
+        def namespaces
+          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 class is already registered in the typemap
+        # Check if the schema is valid
+        def valid?
+          defined?(@validated) && @validated
+        end
+
+        # Only run the validated process if it has not yet been validated
+        def validate
+          validate! unless valid?
+        rescue StandardError
+          GraphQL.logger.warn(+"\e[1m\e[31mSchema #{name} is invalid!\e[0m")
+          raise
+        end
+
+        # Run validations and then mark itself as validated
+        def validate!(*)
+          super if defined? super
+          @validated = true
+        end
+
+        # Check if the class is already registered in the type map
         def registered?
           type_map.object_exist?(self, exclusive: true)
         end
@@ -118,11 +178,7 @@ module Rails # :nodoc:
         # The process to register a class and it's name on the index
         def register!
           return if self == GraphQL::Schema
-
-          unless registered?
-            super if defined? super
-            return type_map.register(self).method(:validate!)
-          end
+          return super unless registered?
 
           current = type_map.fetch(:schema,
             namespaces: namespace,
@@ -130,15 +186,16 @@ module Rails # :nodoc:
             exclusive: true,
           )
 
-          raise ArgumentError, <<~MSG.squish
+          raise ArgumentError, (+<<~MSG).squish
             The #{namespace.inspect} namespace is already assigned to "#{current.name}".
             Please change the namespace for "#{klass.name}" class.
           MSG
         end
 
-        # Checks if a given method can act as resolver
-        def gql_resolver?(method_name)
-          (instance_methods - GraphQL::Schema.instance_methods).include?(method_name)
+        # Hook into the unregister process to reset the subscription provider
+        def unregister!
+          restart_subscriptions
+          super
         end
 
         # Find a given +type+ associated with the schema
@@ -164,6 +221,65 @@ module Rails # :nodoc:
           type_map.fetch!(directive, **xargs)
         end
 
+        # Remove subscriptions by their provided +sids+
+        def remove_subscriptions(*sids)
+          subscription_provider&.remove(*sids)
+        end
+
+        # Add a new subscription using all the provided request subscription
+        # objects
+        def add_subscriptions(*subscriptions)
+          subscription_provider.add(*subscriptions)
+        end
+
+        # The the schema is unloaded, we need to make sure that the provider
+        # can smoothly shutdown itself
+        def restart_subscriptions
+          return unless defined?(@subscription_provider) && !@subscription_provider.nil?
+          subscription_provider.shutdown
+        end
+
+        # Checks if the given +operation+ can be subscribed to
+        def accepts_subscription?(operation)
+          subscription_provider.accepts?(operation)
+        end
+
+        # This receives a request subscription object and return an id for that.
+        # By default, it just produces a random uuid
+        def subscription_id_for(*)
+          SecureRandom.uuid
+        end
+
+        # Simple delegator to the cache store set on the schema config, mapped
+        # to +exist?+
+        def cached?(name, options = nil)
+          config.cache.exist?(expand_cache_key(name), options)
+        end
+
+        # Simple delegator to the cache store set on the schema config, mapped
+        # to +delete+
+        def delete_from_cache(name, options = nil)
+          config.cache.delete(expand_cache_key(name), options)
+        end
+
+        # Simple delegator to the cache store set on the schema config, mapped
+        # to +read+
+        def read_from_cache(name, options = nil)
+          config.cache.read(expand_cache_key(name), options)
+        end
+
+        # Simple delegator to the cache store set on the schema config, mapped
+        # to +write+
+        def write_on_cache(name, value, options = nil)
+          config.cache.write(expand_cache_key(name), value, options)
+        end
+
+        # Simple delegator to the cache store set on the schema config, mapped
+        # to +fetch+
+        def fetch_from_cache(name, options = nil)
+          config.cache.fetch(expand_cache_key(name), options)
+        end
+
         # Describe a schema as a GraphQL string
         def to_gql(**xargs)
           ToGQL.describe(self, **xargs)
@@ -171,12 +287,84 @@ module Rails # :nodoc:
 
         protected
 
-          # TODO: Maybe provide an optional 'Any' scalar
+          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
+
+            # The only way to actually get the namespace into the cache prefix
+            subclass.config.define_singleton_method(:cache_prefix) do
+              self[:cache_prefix] ||= "#{GraphQL.config.cache_prefix}#{subclass.namespace}/"
+            end
+          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)
+            source = caller_locations(2, 1).first.path
+
+            absolute = dir.start_with?(File::SEPARATOR)
+            path = recursive ? File.join('**', '*.rb') : '*.rb'
+            dir = File.expand_path(dir, File.dirname(source)) unless absolute
+
+            list = Dir.glob(File.join(dir, path)).select do |file_name|
+              file_name != source
+            end
+
+            type_map.add_dependencies(list, to: namespace)
+          end
+
+          alias load_current_directory load_directory
+
+          # Load a list of known dependencies based on the given +type+
+          def load_dependencies(type, *list)
+            GraphQL.add_dependencies(type, *list, to: namespace)
+          end
+
+          # A syntax sugar for +load_dependencies(:directive, *list)+
+          def load_directives(*list)
+            load_dependencies(:directive, *list)
+          end
+
+          # A syntax sugar for +load_dependencies(:source, *list)+
+          def load_sources(*list, build: false)
+            load_dependencies(:source, *list)
+            build_all_sources if build
+          end
+
+          # Build all sources that has the belongs to the current namespace
+          def build_all_sources
+            GraphQL::Source.descendants.each do |klass|
+              next if klass.abstract?
+
+              ns = klass.namespaces
+              klass.build_all if (ns.blank? && namespace == :base) ||
+                ns == namespace || ns.try(:include?, namespace)
+            end
+          end
+
+          # Make sure to prefix the cache key
+          def expand_cache_key(name)
+            if name.is_a?(String)
+              name = +"#{config.cache_prefix}#{name}"
+            elsif name.respond_to?(:cache_key=)
+              name.cache_key = +"#{config.cache_prefix}#{name.cache_key}"
+            end
+
+            name
+          end
 
           # Generate the helper methods to easily create types within the
           # definition of the schema
           GraphQL::Type::KINDS.each do |kind|
             class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def load_#{kind.underscore.pluralize}(*list)
+                load_dependencies(:#{kind.underscore}, *list)
+              end
+
               def #{kind.underscore}(name, **xargs, &block)
                 create_type(name, :#{kind}, **xargs, &block)
               end
@@ -184,11 +372,13 @@ module Rails # :nodoc:
           end
 
           # Helper method to create a single source
-          def source(object, superclass = nil, **xargs, &block)
+          def source(object, superclass = nil, build: true, **xargs, &block)
             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
 
@@ -198,16 +388,16 @@ module Rails # :nodoc:
               end
 
               instance_exec(&block) if block.present?
-              build!
+              build_all if create_and_build
             end
           end
 
           # Helper method to create multiple sources with the same type
-          def sources(*list, of_type: nil, &block)
+          def sources(*list, of_type: nil, build: true, &block)
             list = list.flatten
 
             of_type ||= GraphQL::Source.find_for!(list.first)
-            list.each { |object| source(object, of_type, &block) }
+            list.each { |object| source(object, of_type, build: build, &block) }
           end
 
           # A simpler way to create a new type object without having to create
@@ -235,20 +425,24 @@ module Rails # :nodoc:
 
             klass_name = name.classify.demodulize
             klass_name += xargs[:suffix] if xargs.key?(:suffix) &&
-              !klass_name.ends_with?(xargs[: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
+              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
+              raise DefinitionError, (+<<~MSG).squish unless valid
                 The given "#{superclass}" superclass does not inherites from
                 #{base_class.name} class.
               MSG
@@ -261,12 +455,10 @@ module Rails # :nodoc:
               klass.is_a?(Helpers::WithAssignment)
 
             klass.set_namespace(namespace)
-            klass.instance_exec(&block) if block.present?
+            klass.module_exec(&block) if block.present?
             klass
           end
       end
     end
-
-    ActiveSupport.run_load_hooks(:graphql, Schema)
   end
 end

data/lib/rails/graphql/shortcuts.rb

@@ -4,13 +4,20 @@
 module GraphQL
   # 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',
-    Mutation:           '::Rails::GraphQL::Mutation',
+    GlobalID:           '::Rails::GraphQL::GlobalID',
     Request:            '::Rails::GraphQL::Request',
     Schema:             '::Rails::GraphQL::Schema',
     Source:             '::Rails::GraphQL::Source',
+    Type:               '::Rails::GraphQL::Type',
+
+    Query:              '::Rails::GraphQL::Alternative::Query',
+    Mutation:           '::Rails::GraphQL::Alternative::Mutation',
+    Subscription:       '::Rails::GraphQL::Alternative::Subscription',
 
     Enum:               '::Rails::GraphQL::Type::Enum',
     Input:              '::Rails::GraphQL::Type::Input',
@@ -22,6 +29,7 @@ module GraphQL
     ProxyField:         '::Rails::GraphQL::Field::ProxyField',
     AssociationField:   '::Rails::GraphQL::Field::AssociationField',
 
+    BaseSource:         '::Rails::GraphQL::Source::BaseSource',
     ActiveRecordSource: '::Rails::GraphQL::Source::ActiveRecordSource',
   }.freeze
 
@@ -38,8 +46,9 @@ module GraphQL
   DIRECTIVE_SHORTCUTS = %i[DeprecatedDirective IncludeDirective SkipDirective].freeze
 
   class << self
-    delegate(:to_gql, :to_graphql, :type_map, to: 'Rails::GraphQL')
-    delegate(*DIRECTIVE_SHORTCUTS, to: 'Rails::GraphQL::Directive')
+    delegate *DIRECTIVE_SHORTCUTS, to: 'Rails::GraphQL::Directive'
+    delegate :add_dependencies, :configure, :config, :to_gql, :to_graphql, :type_map,
+      to: 'Rails::GraphQL'
 
     # See {Request}[rdoc-ref:Rails::GraphQL::Request]
     def request(*args, **xargs)
@@ -53,6 +62,16 @@ module GraphQL
 
     alias perform execute
 
+    # See {Request}[rdoc-ref:Rails::GraphQL::Request]
+    def compile(*args, **xargs)
+      Rails::GraphQL::Request.compile(*args, **xargs)
+    end
+
+    # See {Request}[rdoc-ref:Rails::GraphQL::Request]
+    def valid?(*args, **xargs)
+      Rails::GraphQL::Request.valid?(*args, **xargs)
+    end
+
     # See {CONST_SHORTCUTS}[rdoc-ref:GraphQL::CONST_SHORTCUTS]
     def const_defined?(name, *)
       name = :"ActiveRecord#{name[2..-1]}" if name[0..1] === 'AR'

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

@@ -9,16 +9,17 @@ module Rails
         sti_interface? ? interface_class : super
       end
 
-      # Get all unique attribute names that exists in the current model
-      def reflection_attributes(holder)
-        items = []
-        each_reflection(holder) do |item|
-          next unless item.belongs_to?
-          next items << item.foreign_key.to_s unless item.polymorphic?
-          items += [item.foreign_type, item.foreign_key]
+      # List of all columns that should be threated as IDs
+      # TODO: Add a exclusive cache for the build process
+      def id_columns
+        @id_columns ||= begin
+          result = Set.new(GraphQL.enumerate(primary_key))
+          each_reflection.each_with_object(result) do |item, arr|
+            next unless item.belongs_to?
+            arr << item.foreign_key.to_s
+            arr << item.foreign_key if item.polymorphic?
+          end
         end
-
-        items.compact.flatten.unshift(primary_key)
       end
 
       # Iterate over all the attributes, except the primary key, from the model
@@ -27,26 +28,32 @@ module Rails
       def each_attribute(holder, skip_primary_key = true)
         adapter_key = GraphQL.ar_adapter_key(adapter_name)
 
-        skip_fields = skips_for(holder).map(&:to_s)
+        skip_fields = Set.new
         skip_fields << model.inheritance_column
         skip_fields << primary_key unless skip_primary_key
 
-        send("#{adapter_key}_attributes") do |attribute, *args|
-          yield attribute, *args unless skip_fields.include?(attribute)
+        send(:"#{adapter_key}_attributes") do |attribute, *args, **xargs|
+          yield(attribute, *args, **xargs) unless skip_fields.include?(attribute)
         end
       end
 
       # Iterate over all the model reflections
-      # TODO: Turn into an enumerator
-      def each_reflection(holder)
-        skip_fields = skips_for(holder).map(&:to_s)
-        model._reflections.each_value do |reflection|
-          next if skip_fields.include?(reflection.name.to_s)
-
+      def each_reflection(&block)
+        model._reflections.each_value.select do |reflection|
           reflection = model._reflections[reflection.to_s] \
             unless reflection.is_a?(abstract_reflection)
 
-          yield reflection unless reflection.nil?
+          !reflection.nil?
+        end.each(&block)
+      end
+
+      # Build arguments that correctly reflect the primary key, as a single
+      # column or as an array of columns
+      def build_primary_key_arguments(holder)
+        if primary_key.is_a?(::Array)
+          primary_key.each { |key| holder.argument(key, :id, null: false) }
+        else
+          holder.argument(primary_key, :id, null: false)
         end
       end
 
@@ -65,22 +72,22 @@ module Rails
         def build_enum_types
           return remove_instance_variable(:@enums) if enums.blank?
 
-          @enums = enums.map do |attribute, setting|
-            [attribute.to_s, create_enum(attribute.to_s, setting, once: true)]
+          @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)
           rescue DuplicatedError
             next
-          end.compact.to_h.freeze
+          end.freeze
         end
 
         # Build all necessary attribute fields into the given +holder+
         def build_attribute_fields(holder, **field_options)
-          attributes_as_ids = reflection_attributes(holder)
           each_attribute(holder) do |key, type, **options|
-            next if skip.include?(key) || holder.field?(key)
+            next if holder.field?(key) || skip_field?(key, on: holder.kind)
 
             str_key = key.to_s
             type = (defined?(@enums) && @enums.key?(str_key) && @enums[str_key]) ||
-              (attributes_as_ids.include?(str_key) && :id) || type
+              (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] || {}))
@@ -89,15 +96,19 @@ module Rails
 
         # Build all necessary reflection fields into the given +holder+
         def build_reflection_fields(holder)
-          each_reflection(holder) do |item|
-            next if holder.field?(item.name)
+          return unless with_associations?
+
+          each_reflection do |item|
+            next if holder.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?
 
               options = reflection_to_options(item)
 
-              if type <= Source::ActiveRecordSource
+              if type <= Source::Base
                 source_name = item.collection? ? type.plural : type.singular
                 proxy_options = options.merge(alias: reflection.name, of_type: :proxy)
 
@@ -106,21 +117,24 @@ module Rails
                 end
               end
 
-              field ||= holder.field(item.name, type, **options)
-              field.before_resolve(:preload_association, item.name)
-              field.before_resolve(:build_association_scope, item.name)
-              field.resolve(:parent_owned_records, item.collection?)
+              if (field ||= holder.safe_field(item.name, type, **options))
+                field.before_resolve(:preload_association, item.name)
+                field.before_resolve(:build_association_scope, item.name)
+                field.resolve(:parent_owned_records, item.collection?)
+              end
             end
           end
         end
 
         # Build all +accepts_nested_attributes_for+ inside the input object
         def build_reflection_inputs(holder)
+          return unless with_associations?
+
           model.nested_attributes_options.each_key do |reflection_name|
             next if (reflection = model._reflect_on_association(reflection_name)).nil?
 
             expected_name = reflection.klass.name.tr(':', '')
-            expected_name += 'Input' unless expected_name.ends_with?('Input')
+            expected_name += 'Input' unless expected_name.end_with?('Input')
 
             type_map_after_register(expected_name) do |input|
               options = reflection_to_options(reflection).merge(null: true)
@@ -130,14 +144,14 @@ module Rails
           end
         end
 
-        # Transform a replection into a field options
+        # Transform a reflection into a field options
         def reflection_to_options(reflection)
           options = { array: reflection.collection? }
 
           required = options[:array]
           required ||= attr_required?(reflection.name)
           required ||= attr_required?(reflection.association_foreign_key) \
-            if reflection.belongs_to?
+            if reflection.belongs_to? && !reflection.options[:optional]
 
           options[:nullable] = !options[:array]
           options[:null] = !required