rails-graphql 0.1.0

data/lib/rails/graphql/request/steps/prepareable.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # Helper methods for the prepare step of a request
+      module Prepareable
+        # Prepare the object
+        def prepare!
+          capture_exception(:prepare) { prepare }
+        end
+
+        protected
+
+          # Normal mode of the prepare step
+          def prepare
+            return if invalid?
+            prepare_then { prepare_fields }
+          end
+
+          # The actual process that prepare the object
+          def prepare_then(after_block = nil, &block)
+            return if invalid?
+            stacked do
+              block.call if block.present?
+              trigger_event(:prepared)
+              after_block.call if after_block.present?
+            end
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/request/steps/resolveable.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # Helper methods for the resolve step of a request
+      module Resolveable
+        # Resolve the object
+        def resolve!
+          capture_exception(:resolve) { resolve }
+        end
+
+        protected
+
+          # Normal mode of the resolve step
+          def resolve
+            invalid? ? try(:resolve_invalid) : resolve_then
+          end
+
+          # The actual process that resolve the object
+          def resolve_then(after_block = nil, &block)
+            return if invalid?
+            stacked do
+              block.call if block.present?
+              trigger_event(:finalize)
+              after_block.call if after_block.present?
+            end
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/request/strategy.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # = GraphQL Request Strategy
+      #
+      # This is the base class for the strategies of resolving a request.
+      class Strategy
+        extend ActiveSupport::Autoload
+
+        autoload :DynamicInstance
+
+        eager_autoload do
+          autoload :SequencedStrategy
+          autoload :MultiQueryStrategy
+        end
+
+        # Configurations for the prepare step
+        PREPARE_XARGS = { object?: true, reverse?: true }.freeze
+
+        # The priority of the strategy
+        class_attribute :priority, instance_accessor: false, default: 1
+
+        delegate :operations, :errors, :response, :schema, to: :request
+
+        attr_reader :listeners, :request, :context
+
+        class << self
+          # Check if the strategy can resolve the given +request+. By default,
+          # strategies cannot resolve a request. Override this method with a
+          # valid checker.
+          def can_resolve?(_)
+            false
+          end
+        end
+
+        def initialize(request)
+          @request = request
+          collect_request_listeners
+        end
+
+        # Executes the strategy in the normal mode
+        def resolve!
+          raise NotImplementedError
+        end
+
+        # Find a given +type+ and store it on request cache
+        def find_type!(type)
+          request.cache(:types)[type] ||= schema.find_type!(type)
+        end
+
+        # Find a given +directive+ and store it on request cache
+        def find_directive!(directive)
+          request.cache(:directives)[directive] ||= schema.find_directive!(directive)
+        end
+
+        # Check if it's enabled to collect listeners
+        def add_listeners?
+          !listeners.frozen?
+        end
+
+        # Check if any listener were actually added
+        def listeners?
+          listeners.any?
+        end
+
+        # Check if any object is listening to a given +event_name+
+        def listening_to?(event_name)
+          listeners? && listeners.key?(event_name.to_sym)
+        end
+
+        # When running an stacked operation, make sure that the object was added
+        # to the list of the listeners
+        def stacked(object, &block)
+          request.stacked(object, &block)
+        end
+
+        # When a +field+ has a perform step, run it under the context of the
+        # prepared value from the data pool
+        def perform(field)
+          context.stacked(@data_pool[field]) do
+            safe_store_data(field) do
+              Event.trigger(:perform, field, self, &field.performer)
+            end
+          end
+        end
+
+        # Execute the prepare step for the given +field+ and execute the given
+        # block using context stack
+        def prepare(field, &block)
+          value = safe_store_data(field) do
+            Event.trigger(:prepare, field, self, **PREPARE_XARGS)
+          end
+
+          return context.stacked(value, &block) unless value.nil?
+
+          stack = field.all_events[:prepare].map { |cb| cb.source_location.join(':') }
+          request.report_node_error(<<~MSG.squish, field, stack: stack.reverse)
+            It is expected to get a result from prepare events
+          MSG
+        end
+
+        # Resolve a value for a given object, It uses the +args+ to prevent
+        # problems with nil values.
+        def resolve(field, *args, array: false, decorate: false, &block)
+          rescue_with_handler(field: field) do
+            prepared = data_for(args, field)&.last
+            args << Event.trigger(:resolve, field, self, prepared: prepared,
+              &field.resolver) if field.try(:dynamic_resolver?)
+          end if args.size.zero?
+
+          # Now we have a value to set on the context
+          value = args.last
+          value = field.decorate(value) if decorate
+          context.stacked(value) do |current|
+            if !array
+              block.call(current)
+              field.write_value(current)
+            else
+              field.write_array(current, &block)
+            end
+          end
+        end
+
+        # Safe trigger an event and ensure to send any exception to the request
+        # handler
+        def rescue_with_handler(**extra)
+          yield
+        rescue => error
+          request.rescue_with_handler(error, **extra)
+        end
+
+        # Check if the given class is in the pool, or add a new instance to the
+        # pool, and then set the instance as the current object
+        def instance_for(klass)
+          @objects_pool[klass] ||= begin
+            @objects_pool.each_value.find do |value|
+              value.is_a?(klass)
+            end || begin
+              instance = klass.new
+              instance = DynamicInstance.new(instance) unless klass < GraphQL::Schema ||
+                klass < GraphQL::Type::Object
+              instance
+            end
+          end
+        end
+
+        # Trigger an event using a set of filtered objects from +request.stack+.
+        # {+trigger_all+}[rdoc-ref:Rails::GraphQL::Event#trigger_all].
+        # The filter is based on the listeners that were collected by the
+        # strategy.
+        def trigger_event(event_name, **xargs)
+          return unless listening_to?(event_name)
+
+          objects = listeners[event_name.to_sym] & request.stack
+          return if objects.empty?
+
+          Event.trigger(event_name, objects, self, **xargs)
+        end
+
+        # Check what kind of event listeners the object have, in order to speed
+        # up processing by avoiding unnecesary event instances
+        def add_listener(object)
+          return unless add_listeners?
+
+          object.all_listeners.each do |event_name|
+            listeners[event_name] << object
+          end
+        end
+
+        # Store a given resolve +value+ for a given +field+
+        def store_data(field, value)
+          @data_pool[field] = value
+        end
+
+        # Only store a given +value+ for a given +field+ if it is not set yet
+        def safe_store_data(field, value = nil)
+          rescue_with_handler(field: field) do
+            value ||= yield if block_given?
+            @data_pool[field] ||= value unless value.nil?
+          end
+        end
+
+        protected
+
+          # Clean and enable the collecting of listeners
+          def release_listeners!
+            @listeners = @base_listeners.dup
+          end
+
+          # Disable the collecting of listeners
+          def lock_listeners!
+            listeners.freeze
+          end
+
+          # A shortcut for +release_listeners!+ and +lock_listeners!+
+          def collect_listeners
+            release_listeners!
+            yield
+            lock_listeners!
+          end
+
+          # This is where the strategy is most effective. By preparing the tree,
+          # it can load data in a pretty smart way
+          def collect_data
+            @data_pool = {}
+            @objects_pool = {}
+            @context = request.build(Request::Context)
+
+            # TODO: Create an orchestrator to allow cross query loading
+            yield if listening_to?(:prepare)
+          end
+
+          # Initiate the response context, named
+          # ({Request::Context}[rdoc-ref:Rails::GraphQL::Request::Context])
+          # and start collecting results
+          def collect_response
+            yield
+          ensure
+            @context = @objects_pool = @data_pool = @listeners = nil
+          end
+
+          # Fetch the data for a given field and set as the first element
+          # of the returned list
+          def data_for(result, field)
+            return result << @data_pool[field] if @data_pool.key?(field)
+            return if field.entry_point?
+
+            current, key = context.current_value, field.method_name
+            return result << current.public_send(key) if current.respond_to?(key)
+
+            result << current[key] if current.respond_to?(:key?) && current.key?(key)
+          end
+
+        private
+
+          # Collect the base listeners from the request
+          def collect_request_listeners
+            @listeners = Hash.new { |h, k| h[k] = [] }
+            add_listener(request)
+
+            lock_listeners!
+            @base_listeners = @listeners
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/request/strategy/dynamic_instance.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # = GraphQl Strategy Dynamic Instance
+      #
+      # When an event is call on non-object types, this class allows both
+      # finding a method on two different places, the interface or union
+      # definition, or on the currect object type-class.
+      class Strategy::DynamicInstance < Helpers::AttributeDelegator
+        def instance_variable_set(ivar, value)
+          __getobj__.instance_variable_set(ivar, value)
+          __current_object__&.instance_variable_set(ivar, value)
+        end
+
+        private
+
+          def respond_to_missing?(method_name, include_private = false) # :nodoc:
+            __current_object__&.respond_to?(method_name, include_private) || super
+          end
+
+          def method_missing(method_name, *args, **xargs, &block) # :nodoc:
+            object = __current_object__
+
+            return super unless object&.respond_to?(method_name)
+            object.public_send(method_name, *args, **xargs, &block)
+          end
+
+          def __current_object__ # :nodoc:
+            return unless __getobj__.instance_variable_defined?(:@event)
+
+            event = __getobj__.instance_variable_get(:@event)
+            return if event.nil? || (object = event.source.try(:current_object)).nil?
+
+            event.strategy.instance_for(object)
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/request/strategy/multi_query_strategy.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # = GraphQl Multi Query Strategy
+      #
+      # This is a resolution strategy to solve requests that only contain
+      # queries, allowing the strategy to collect all the information for all
+      # the queries in a single step before resolving it.
+      class Strategy::MultiQueryStrategy < Strategy
+        self.priority = 10
+
+        def self.can_resolve?(request) # :nodoc:
+          request.operations.values.all?(&:query?)
+        end
+
+        # Executes the strategy in the normal mode
+        def resolve!
+          response.with_stack(:data) do
+            for_each_operation { |op| collect_listeners { op.organize! } }
+            for_each_operation { |op| collect_data      { op.prepare!  } }
+            for_each_operation { |op| collect_response  { op.resolve!  } }
+          end
+        end
+
+        private
+
+          # Execute a given block for each defined operation
+          def for_each_operation
+            operations.each_value { |op| yield op }
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/request/strategy/sequenced_strategy.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    class Request # :nodoc:
+      # = GraphQl Sequenced Strategy
+      #
+      # This is the default resolution strategy, where each operation is
+      # performed in sequece, and they don't relate to each other in any way.
+      class Strategy::SequencedStrategy < Strategy
+        def self.can_resolve?(_) # :nodoc:
+          true
+        end
+
+        # Executes the strategy in the normal mode
+        def resolve!
+          response.with_stack(:data) do
+            operations.each_value do |op|
+              collect_listeners { op.organize! }
+              collect_data      { op.prepare! }
+              collect_response  { op.resolve! }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/schema.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # = GraphQL Schema
+    #
+    # This is a pure representation of a GraphQL schema.
+    # See: http://spec.graphql.org/June2018/#SchemaDefinition
+    #
+    # In addition to the spec implementation, this also allows separation by
+    # 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]
+    # 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
+    # namespace.
+    class Schema
+      extend Helpers::WithSchemaFields
+      extend Helpers::WithDirectives
+      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
+
+      self.abstract = true
+      self.spec_object = true
+      self.directive_location = :schema
+
+      # Imports schema specific configurations
+      configure do |config|
+        %i[enable_string_collector request_strategies].each do |name|
+          config.send("#{name}=", GraphQL.config.send(name))
+        end
+      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
+
+        # :singleton-method:
+        # Since there are only one schema per namespace, the name is constant
+        def gql_name
+          'schema'
+        end
+
+        alias graphql_name gql_name
+
+        # :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:
+          :schema
+        end
+
+        alias to_sym kind
+
+        # :singleton-method:
+        # Use a soft mode to find a schema associated with a namespace
+        def find(namespace)
+          type_map.fetch(:schema,
+            namespaces: namespace,
+            base_class: :Schema,
+            exclusive: true,
+          )
+        end
+
+        # :singleton-method:
+        # Find the schema associated to the given namespace
+        def find!(namespace)
+          type_map.fetch!(:schema,
+            namespaces: namespace,
+            base_class: :Schema,
+            exclusive: true,
+          )
+        end
+
+        # :singleton-method:
+        # For campatibility with type map
+        def eager_load!
+          TypeMap.loaded! :Schema
+        end
+
+        # Find all types that are available for the current schema
+        def types(base_class: :Type, &block)
+          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)
+        end
+
+        # Schemas are assigned to a single namespace and not inherited
+        def namespace(*list)
+          list.blank? ? (namespaces.first || :base) : set_namespace(*list)
+        end
+
+        # Check if the class is already registered in the typemap
+        def registered?
+          type_map.object_exist?(self, exclusive: true)
+        end
+
+        # 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
+
+          current = type_map.fetch(:schema,
+            namespaces: namespace,
+            base_class: :Schema,
+            exclusive: true,
+          )
+
+          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)
+        end
+
+        # Find a given +type+ associated with the schema
+        def find_type(type, **xargs)
+          xargs[:base_class] = :Type
+          xargs[:namespaces] = namespaces
+          type_map.fetch(type, **xargs)
+        end
+
+        # Find a given +type+ associated with the schema. It will raise an
+        # exception if the +type+ can not be found
+        def find_type!(type, **xargs)
+          xargs[:base_class] = :Type
+          xargs[:namespaces] = namespaces
+          type_map.fetch!(type, **xargs)
+        end
+
+        # Find a given +directive+ associated with the schema. It will raise an
+        # exception if the +directive+ can not be found
+        def find_directive!(directive, **xargs)
+          xargs[:base_class] = :Directive
+          xargs[:namespaces] = namespaces
+          type_map.fetch!(directive, **xargs)
+        end
+
+        # Describe a schema as a GraphQL string
+        def to_gql(**xargs)
+          ToGQL.describe(self, **xargs)
+        end
+
+        protected
+
+          # TODO: Maybe provide an optional 'Any' scalar
+
+          # 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 #{kind.underscore}(name, **xargs, &block)
+                create_type(name, :#{kind}, **xargs, &block)
+              end
+            RUBY
+          end
+
+          # Helper method to create a single source
+          def source(object, superclass = nil, **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
+
+              instance_exec(&block) if block.present?
+              build!
+            end
+          end
+
+          # Helper method to create multiple sources with the same type
+          def sources(*list, of_type: nil, &block)
+            list = list.flatten
+
+            of_type ||= GraphQL::Source.find_for!(list.first)
+            list.each { |object| source(object, of_type, &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
+          end
+      end
+    end
+
+    ActiveSupport.run_load_hooks(:graphql, Schema)
+  end
+end