rails-graphql 0.2.1 → 1.0.0.rc1

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,25 +33,31 @@ 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
         def gql_name
-          'schema'
+          '__Schema'
         end
 
         alias graphql_name gql_name
@@ -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,51 @@ 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
 
-        # Check if the class is already registered in the typemap
+        # Add compatibility to the list of namespaces
+        def namespaces
+          namespace
+        end
+
+        # 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 +163,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 +171,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,19 +206,182 @@ module Rails # :nodoc:
           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)
+        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)
         end
 
         protected
+          attr_writer :subscription_provider
+
+          # Mark the given class to be pending of registration
+          def inherited(subclass)
+            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
+
+          # 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)
+            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
 
-          # TODO: Maybe provide an optional 'Any' scalar
+          # 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,89 +389,29 @@ 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'
-            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!
-            end
+            create_type(object, superclass, **xargs, &block)
           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
           # 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.ends_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
-            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.instance_exec(&block) if block.present?
-            klass
+          def create_type(*args, **xargs, &block)
+            GraphQL::Type.create!(self, *args, **xargs, &block)
           end
       end
     end
-
-    ActiveSupport.run_load_hooks(:graphql, Schema)
   end
 end

data/lib/rails/graphql/shortcuts.rb

@@ -2,15 +2,30 @@
 
 # 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',
-    Mutation:           '::Rails::GraphQL::Mutation',
+    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',
@@ -19,9 +34,7 @@ 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
 
@@ -35,11 +48,13 @@ 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(: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 +68,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'