rails-graphql 0.1.0

data/lib/rails/graphql/callback.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    # = Rails GraphQL Callback
+    #
+    # An extra powerfull proc that can handle way more situations than the
+    # original block caller
+    class Callback
+      attr_reader :event_name, :block, :target, :filters
+
+      delegate :event_filters, to: :target
+      delegate :callback_inject_arguments, :callback_inject_named_arguments,
+        to: '::Rails::GraphQL.config'
+
+      # Directives need to be contextualized by the given instance as +context+
+      def self.set_context(item, context)
+        lambda { |*args| item.call(*args, context: context) }
+      end
+
+      def initialize(target, event_name, *args, **xargs, &block)
+        raise ::ArgumentError, <<~MSG.squish if block.nil? && !args.first.present?
+          Either provide a block or a method name when setting a #{event_name}
+          callback on #{target.inspect}.
+        MSG
+
+        if block.nil?
+          block = args.shift
+          valid_format = block.is_a?(Symbol) || block.is_a?(Proc)
+          raise ::ArgumentError, <<~MSG.squish unless valid_format
+            The given #{block.class.name} class is not a valid callback.
+          MSG
+        end
+
+        @target = target
+        @event_name = event_name
+
+        @pre_args = args
+        @pre_xargs = xargs.slice!(*event_filters.keys)
+        @filters = xargs.map do |key, value|
+          [key, event_filters[key][:sanitizer]&.call(value) || value]
+        end.to_h
+
+        @block = block
+      end
+
+      # This does the whole checking and preparation in order to really execute
+      # the callback method
+      def call(event, context: nil)
+        return unless event.name === event_name && can_run?(event)
+        block.is_a?(Symbol) ? call_symbol(event) : call_proc(event, context)
+      end
+
+      # Get a described source location for the callback
+      def source_location
+        block.is_a?(Proc) ? block.source_location : [
+          "(symbolized-callback/#{target.inspect})",
+          block,
+        ]
+      end
+
+      # This basically allows the class to be passed as +&block+
+      def to_proc
+        method(:call).to_proc.tap do |block|
+          block.define_singleton_method(:source_location, &method(:source_location))
+        end
+      end
+
+      private
+
+        # Using the filters, check if the current callback can be executed
+        def can_run?(event)
+          filters.all? { |key, options| event_filters[key][:block].call(options, event) }
+        end
+
+        # Call the callback block as a symbol
+        def call_symbol(event)
+          owner = target.try(:proxied_owner) || target.try(:owner) || target
+          event.on_instance(owner) do |instance|
+            block = instance.method(@block)
+            args, xargs = collect_parameters(event, block)
+            block.call(*args, **xargs)
+          end
+        end
+
+        # Call the callback block as a proc
+        def call_proc(event, context = nil)
+          args, xargs = collect_parameters(event)
+          (context || event).instance_exec(*args, **xargs, &block)
+        end
+
+        # Read the arguments needed for a block then collect them from the
+        # event and return the execution args
+        def collect_parameters(event, block = @block)
+          args_source = event.send(:args_source) || event
+          start_args = [@pre_args.deep_dup, @pre_xargs.deep_dup]
+          return start_args unless inject_arguments?
+
+          # TODO: Maybe we need to turn procs into lambdas so the optional
+          # arguments doesn't suffer any kind of change
+          idx = -1
+          block.parameters.each_with_object(start_args) do |(type, name), result|
+            case type
+            when :opt, :req
+              idx += 1
+              next unless callback_inject_arguments
+              result[0][idx] ||= event.parameter(name) if event.parameter?(name)
+            when :keyreq
+              next unless callback_inject_named_arguments
+              result[1][name] ||= args_source[name]
+            when :key
+              next unless callback_inject_named_arguments
+              result[1][name] ||= args_source[name] if args_source.key?(name)
+            end
+          end
+        end
+
+        # Check if the callback should inject arguments
+        def inject_arguments?
+          callback_inject_arguments || callback_inject_named_arguments
+        end
+    end
+  end
+end

data/lib/rails/graphql/collectors.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Collectors # :nodoc:
+      extend ActiveSupport::Autoload
+
+      autoload :HashCollector
+      autoload :IdentedCollector
+      autoload :JsonCollector
+
+    end
+  end
+end

data/lib/rails/graphql/collectors/hash_collector.rb

@@ -0,0 +1,83 @@
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Collectors # :nodoc:
+      # This collector helps building a JSON response using the hash approach,
+      # where the value is kept as an hash and later turn into a string
+      class HashCollector
+        def initialize(request)
+          @request = request
+          @stack = []
+          @data = {}
+        end
+
+        # Shortcut for starting and ending a stack while execute a block.
+        def with_stack(key, array: false, plain: false)
+          return unless block_given?
+          start_stack(array, plain)
+          yield
+          end_stack(key, array, plain)
+        rescue
+          pop_size = array && !plain ? 2 : 1
+          @data = @stack.pop(pop_size).first
+          raise
+        end
+
+        # Add the given +value+ to the given +key+.
+        def add(key, value)
+          @data.is_a?(Array) ? @data << value : @data[key.to_s] = value
+        end
+
+        alias safe_add add
+
+        # Serialize is a helper to call the correct method on types before add
+        def serialize(klass, key, value)
+          add(key, klass.as_json(value))
+        end
+
+        # Mark the start of a new element on the array.
+        def next
+          return unless @stack.last.is_a?(Array)
+          @stack.last << @data
+          @data = {}
+        end
+
+        # Append to the responsa data all the errors that happened during the
+        # request process
+        def append_errors(errors)
+          return if errors.empty?
+          @data['errors'] = errors.to_a
+        end
+
+        # Return the generated object
+        def to_h
+          @data
+        end
+
+        # Generate the JSON string result
+        def to_s
+          GraphQL.config.encode_with_active_support? \
+            ? ::ActiveSupport::JSON.encode(@data) \
+            : ::JSON.generate(@data)
+        end
+
+        private
+
+          # Start a new part of the collector. When set +as_array+, the result
+          # of the stack will be an array.
+          def start_stack(as_array = false, plain_array = false)
+            @stack << @data
+            @stack << [] if as_array && !plain_array
+            @data = as_array && plain_array ? [] : {}
+          end
+
+          # Finalize a stack and set the result on the given +key+.
+          def end_stack(key, as_array = false, plain_array = false)
+            result = as_array && !plain_array ? @stack.pop : @data
+
+            @data = @stack.pop
+            add(key, result)
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/collectors/idented_collector.rb

@@ -0,0 +1,73 @@
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Collectors # :nodoc:
+      # This collector helps building a indented string
+      class IdentedCollector
+        def initialize(initial = 0, size = 2, auto_eol: true)
+          @size = size
+          @val = [[initial, '']]
+          @auto_eol = auto_eol
+        end
+
+        def indented(start = nil, finish = nil, auto_eol = @auto_eol)
+          self << start unless start.nil?
+
+          indent
+          yield
+
+          @val.last.pop while @val.last.last.blank?
+          unindent
+
+          @val.pop(2) if blank?(-2)
+
+          self << finish unless finish.nil?
+          eol if auto_eol
+          self
+        end
+
+        def value
+          @val.map do |(ident, *content)|
+            next if content.size.eql?(1) && content.first.blank?
+            ident = (' ' * ident)
+            ident + content.join("\n#{ident}")
+          end.compact.join("\n")
+        end
+
+        def puts(str)
+          @val.last.last << str
+          eol
+        end
+
+        def <<(str)
+          @val.last.last << str
+          self
+        end
+
+        def eol
+          @val.last << ''
+          self
+        end
+
+        def indent
+          return @val.last[0] += @size if blank?
+          @val << [last_ident + @size, '']
+          self
+        end
+
+        def unindent
+          return @val.last[0] -= @size if blank?
+          @val << [last_ident - @size, '']
+          self
+        end
+
+        def last_ident
+          @val.last.first
+        end
+
+        def blank?(pos = -1)
+          @val[pos].size.eql?(2) && @val[pos].last.empty?
+        end
+      end
+    end
+  end
+end

data/lib/rails/graphql/collectors/json_collector.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    module Collectors # :nodoc:
+      # This collector helps building a JSON response using the string approach,
+      # which has better performance, since all the encoding is performed up
+      # front. The drawback is that it can't return an hash.
+      class JsonCollector
+        def initialize(request)
+          @request = request
+
+          @current_value = String.new
+          @stack_value = []
+
+          @current_array = false
+          @stack_array = []
+
+          @current_plain_array = false
+          @stack_plain_array = []
+        end
+
+        # Shortcut for starting and ending a stack while execute a block.
+        def with_stack(key, array: false, plain: false)
+          return unless block_given?
+          start_stack(array, plain)
+          yield
+          end_stack(key, array, plain)
+        rescue
+          pop_size = array && !plain ? 2 : 1
+          @current_value = @stack_value.pop(pop_size).first
+          @current_array = @stack_array.pop(pop_size).first
+          raise
+        end
+
+        # Append to the responsa data all the errors that happened during the
+        # request process.
+        def append_errors(errors)
+          return if errors.empty?
+          add('errors', errors.to_json)
+        end
+
+        # Add the given +value+ to the given +key+. Ensure to encode the value
+        # before calling this function.
+        def add(key, value)
+          (@current_value << ',') unless @current_value.blank?
+
+          if @current_array
+            @current_value << value
+          else
+            @current_value << '"'
+            @current_value << key.to_s
+            @current_value << '":'
+            @current_value << value.to_s
+          end
+        end
+
+        # Same as +add+ but this always encode the +value+ beforehand.
+        def safe_add(key, value)
+          add(key, value.nil? ? 'null' : value.to_json)
+        end
+
+        # Serialize is a helper to call the correct method on types before add
+        def serialize(klass, key, value)
+          add(key, klass.to_json(value))
+        end
+
+        # Mark the start of a new element on the array.
+        def next
+          return unless @stack_array.last === :complex
+          (@stack_value.last << ',') unless @stack_value.last.blank?
+          @stack_value.last << to_s
+          @current_value = String.new
+        end
+
+        # Get the current result
+        def to_s
+          @current_array ? "[#{@current_value}]" : "{#{@current_value}}"
+        end
+
+        private
+
+          # Start a new part of the collector. When set +as_array+, the result
+          # of the stack will be encolsed by +[]+.
+          def start_stack(as_array = false, plain_array = false)
+            @stack_value << @current_value
+            @stack_array << @current_array
+
+            if as_array && !plain_array
+              @stack_value << String.new
+              @stack_array << :complex
+              as_array = false
+            end
+
+            @current_value = String.new
+            @current_array = as_array
+          end
+
+          # Finalize a stack and set the result on the given +key+.
+          def end_stack(key, as_array = false, plain_array = false)
+            if as_array && !plain_array
+              @current_value = @stack_value.pop
+              @current_array = @stack_array.pop
+            end
+
+            result = to_s
+            @current_value = @stack_value.pop
+            @current_array = @stack_array.pop
+            add(key, result)
+          end
+      end
+    end
+  end
+end

data/lib/rails/graphql/config.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Rails # :nodoc:
+  module GraphQL # :nodoc:
+    configure do |config|
+      # This exposes the clean path from where a GraphQL request was started
+      config.verbose_logs = true
+
+      # A list of ActiveRecord adapters and their specific internal naming used
+      # to compound the accessors for direct query serialization
+      config.ar_adapters = {
+        'Mysql2'     => :mysql,
+        'PostgreSQL' => :pg,
+        'SQLite'     => :sqlite,
+      }
+
+      # For all the input object type defined, auto add the following prefix to
+      # their name, so we don't have to define classes like +PointInputInput+.
+      config.auto_suffix_input_objects = 'Input'
+
+      # For performance purposes, this gem implements a
+      # {JsonCollector}[rdoc-ref:Rails::GraphQL::Collectors::JsonCollector].
+      # If you prefer to use the normal hash to string serialization, you can
+      # disable this option.
+      config.enable_string_collector = true
+
+      # Specifies if the results of operations should be encoded with
+      # +ActiveSupport::JSON#encode+ instead of the default +JSON#generate+.
+      # See also https://github.com/rails/rails/blob/master/activesupport/lib/active_support/json/encoding.rb
+      config.encode_with_active_support = false
+
+      # Enable the ability of a callback to dynamically inject argumnets to the
+      # calling method.
+      config.callback_inject_arguments = true
+
+      # Enable the ability of a callback to dynamically inject named argumnets
+      # to the calling method.
+      config.callback_inject_named_arguments = true
+
+      # A list of execution strategies. Each application can add their own by
+      # simply append a class name, preferable as string, in this list.
+      config.request_strategies = [
+        'Rails::GraphQL::Request::Strategy::MultiQueryStrategy',
+        'Rails::GraphQL::Request::Strategy::SequencedStrategy',
+      ]
+
+      # TODO: To be implemented
+      # enable_i18n_descriptions
+      # enable_auto_descriptions
+      # allow_query_serialization
+      # source_generate_dependencies
+    end
+
+    # This is the logger for all the operations for GraphQL
+    def self.logger
+      config.logger ||= ActiveSupport::TaggedLogging.new(
+        ActiveSupport::Logger.new(STDOUT),
+      )
+    end
+  end
+end