rails-graphql 0.2.1 → 1.0.0.rc1

data/lib/rails/graphql/argument.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = GraphQL Argument
     #
     # This represents an item from the ArgumentsDefinition, which was supposed
@@ -31,6 +31,7 @@ module Rails # :nodoc:
     #   (defaults to nil).
     class Argument
       include Helpers::WithValidator
+      include Helpers::WithDescription
 
       # TODO: When arguments are attached to output fields they can have
       # directives so add this possibility
@@ -42,19 +43,21 @@ module Rails # :nodoc:
 
       def initialize(
         name,
-        type,
+        type = nil,
         owner:,
         null: true,
         full: false,
         array: false,
         nullable: true,
         default: nil,
-        desc: nil
+        desc: nil,
+        description: nil
       )
         @owner = owner
         @name = name.to_s.underscore.to_sym
         @gql_name = @name.to_s.camelize(:lower)
 
+        type = (name == :id ? :id : :string) if type.nil?
         if type.is_a?(Module) && type < GraphQL::Type
           @type_klass = type
           @type = type.name
@@ -67,7 +70,8 @@ module Rails # :nodoc:
         @nullable = full ? false : nullable
 
         @default = default
-        @desc = desc&.strip_heredoc&.chomp
+        @default = deserialize(@default) if @default.is_a?(::GQLParser::Token)
+        self.description = desc || description
       end
 
       def initialize_copy(*)
@@ -114,14 +118,9 @@ module Rails # :nodoc:
         !!@nullable
       end
 
-      # Return the description of the argument
-      def description
-        @desc
-      end
-
-      # Checks if a description was provided
-      def description?
-        !!@desc
+      # Override to add the kind
+      def description(namespace = nil, *)
+        super(namespace || owner.try(:namespaces), :argument)
       end
 
       # Checks if a given default value was provided
@@ -149,7 +148,7 @@ module Rails # :nodoc:
 
       # Turn the given value into a ruby object through deserialization
       def deserialize(value = nil)
-        value = @default if value.nil?
+        value = as_json if value.nil?
 
         return if value.nil?
         return type_klass.deserialize(value) unless array?
@@ -174,19 +173,19 @@ module Rails # :nodoc:
       def validate!(*)
         super if defined? super
 
-        raise NameError, <<~MSG.squish if gql_name.start_with?('__')
+        raise NameError, (+<<~MSG).squish if gql_name.start_with?('__')
           The name "#{gql_name}" is invalid. Argument names cannot start with "__".
         MSG
 
-        raise ArgumentError, <<~MSG.squish unless type_klass.is_a?(Module)
+        raise ArgumentError, (+<<~MSG).squish unless type_klass.is_a?(Module)
           Unable to find the "#{type.inspect}" input type on GraphQL context.
         MSG
 
-        raise ArgumentError, <<~MSG.squish unless type_klass.input_type?
+        raise ArgumentError, (+<<~MSG).squish unless type_klass.input_type?
           The "#{type_klass.gql_name}" is not a valid input type.
         MSG
 
-        raise ArgumentError, <<~MSG.squish unless default.nil? || valid?(default)
+        raise ArgumentError, (+<<~MSG).squish unless default.nil? || valid?(as_json(default))
           The given default value "#{default.inspect}" is not valid for this argument.
         MSG
       end
@@ -198,14 +197,14 @@ module Rails # :nodoc:
 
       alias_method :&, :+
 
-      def inspect # :nodoc:
-        result = "#{name}: "
-        result += '[' if array?
-        result += type_klass.gql_name
-        result += '!' if array? && !nullable?
-        result += ']' if array?
-        result += '!' unless null?
-        result += " = #{to_hash.inspect}" if default_value?
+      def inspect
+        result = +"#{name}: "
+        result << '[' if array?
+        result << type_klass.gql_name
+        result << '!' if array? && !nullable?
+        result << ']' if array?
+        result << '!' unless null?
+        result << " = #{as_json.inspect}" if default_value?
         result
       end
 

data/lib/rails/graphql/callback.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
+module Rails
+  module GraphQL
     # = Rails GraphQL Callback
     #
-    # An extra powerfull proc that can handle way more situations than the
+    # An extra powerful proc that can handle way more situations than the
     # original block caller
     class Callback
+      EXCLUSIVE_ARGUMENT = :exclusive_callback
+
       attr_reader :event_name, :block, :target, :filters
 
       delegate :event_filters, to: :target
@@ -19,7 +21,7 @@ module Rails # :nodoc:
       end
 
       def initialize(target, event_name, *args, **xargs, &block)
-        raise ::ArgumentError, <<~MSG.squish if block.nil? && !args.first.present?
+        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
@@ -27,7 +29,7 @@ module Rails # :nodoc:
         if block.nil?
           block = args.shift
           valid_format = block.is_a?(Symbol) || block.is_a?(Proc)
-          raise ::ArgumentError, <<~MSG.squish unless valid_format
+          raise ::ArgumentError, (+<<~MSG).squish unless valid_format
             The given #{block.class.name} class is not a valid callback.
           MSG
         end
@@ -35,11 +37,13 @@ module Rails # :nodoc:
         @target = target
         @event_name = event_name
 
+        @exclusive = xargs.delete(EXCLUSIVE_ARGUMENT)
+        @exclusive = target.try(:default_exclusive?, event_name) if @exclusive.nil?
+        @exclusive = true if @exclusive.nil?
+
         @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
+        @filters = xargs
 
         @block = block
       end
@@ -47,19 +51,24 @@ module Rails # :nodoc:
       # This does the whole checking and preparation in order to really execute
       # the callback method
       def call(event, *args, _callback_context: nil, **xargs)
-        return unless event.name === event_name && can_run?(event)
+        return unless event.event_name === event_name && can_run?(event)
 
         block.is_a?(Symbol) \
           ? call_symbol(event, *args, **xargs) \
           : call_proc(event, _callback_context, *args, **xargs)
       end
 
+      # Return if this event is exclusive, so that only the original source of
+      # the callback will be allowed to receive it
+      def exclusive?
+        @exclusive
+      end
+
       # Get a described source location for the callback
       def source_location
-        block.is_a?(Proc) ? block.source_location : [
-          "(symbolized-callback/#{target.inspect})",
-          block,
-        ]
+        block.is_a?(Proc) ? block.source_location : begin
+          [+"(symbolized-callback/#{target.inspect})", block]
+        end
       end
 
       # This basically allows the class to be passed as +&block+
@@ -80,10 +89,16 @@ module Rails # :nodoc:
 
         # 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) }
+          return false if exclusive? && !event.same_source?(target)
+
+          filters.all? do |key, options|
+            target.instance_exec(options, event, &event_filters[key])
+          end
         end
 
         # Call the callback block as a symbol
+        # TODO: Maybe block calling non-public events
+        # TODO: This is the only reason why directives needs an owner
         def call_symbol(event, *args, **xargs)
           event.on_instance(owner) do |instance|
             block = instance.method(@block)
@@ -95,6 +110,7 @@ module Rails # :nodoc:
         # Call the callback block as a proc
         def call_proc(event, context = nil, *args, **xargs)
           args, xargs = collect_parameters(event, [args, xargs])
+          args << event unless inject_arguments? || (block.arity - 1) == args.size
           (context || event).instance_exec(*args, **xargs, &block)
         end
 

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

@@ -1,6 +1,10 @@
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Collectors # :nodoc:
+# frozen_string_literal: true
+
+module Rails
+  module GraphQL
+    module Collectors
+      # = GraphQL Hash Collector
+      #
       # 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
@@ -24,7 +28,12 @@ module Rails # :nodoc:
 
         # Add the given +value+ to the given +key+.
         def add(key, value)
-          @data.is_a?(Array) ? @data << value : @data[key.to_s] = value
+          @data.is_a?(::Array) ? @data << value : @data[key.to_s] = value
+        end
+
+        # Check if a given +key+ has already been added to the current data
+        def key?(key)
+          !@data.is_a?(::Array) && @data.key?(key)
         end
 
         alias safe_add add
@@ -36,16 +45,22 @@ module Rails # :nodoc:
 
         # Mark the start of a new element on the array.
         def next
-          return unless @stack.last.is_a?(Array)
+          return unless @stack.last.is_a?(::Array)
           @stack.last << @data
           @data = {}
         end
 
-        # Append to the responsa data all the errors that happened during the
+        # Append to the response all the errors that happened during the
         # request process
         def append_errors(errors)
           return if errors.empty?
-          @data['errors'] = errors.to_a
+          @data['errors'] = errors.as_json
+        end
+
+        # Append to the response anything added to the extensions
+        def append_extensions(extensions)
+          return if extensions.empty?
+          @data['extensions'] = extensions.as_json
         end
 
         # Return the generated object
@@ -53,6 +68,8 @@ module Rails # :nodoc:
           @data
         end
 
+        alias as_json to_h
+
         # Generate the JSON string result
         def to_s
           GraphQL.config.encode_with_active_support? \
@@ -60,6 +77,8 @@ module Rails # :nodoc:
             : ::JSON.generate(@data)
         end
 
+        alias to_json to_s
+
         private
 
           # Start a new part of the collector. When set +as_array+, the result

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

@@ -1,11 +1,14 @@
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Collectors # :nodoc:
-      # This collector helps building a indented string
+module Rails
+  module GraphQL
+    module Collectors
+      # = GraphQL Idented Collector
+      #
+      # This collector helps building a indented string, most used for
+      # displaying a GraphQL schema
       class IdentedCollector
         def initialize(initial = 0, size = 2, auto_eol: true)
           @size = size
-          @val = [[initial, '']]
+          @val = [[initial, +'']]
           @auto_eol = auto_eol
         end
 
@@ -50,13 +53,13 @@ module Rails # :nodoc:
 
         def indent
           return @val.last[0] += @size if blank?
-          @val << [last_ident + @size, '']
+          @val << [last_ident + @size, +'']
           self
         end
 
         def unindent
           return @val.last[0] -= @size if blank?
-          @val << [last_ident - @size, '']
+          @val << [last_ident - @size, +'']
           self
         end
 

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

@@ -1,16 +1,21 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Collectors # :nodoc:
+module Rails
+  module GraphQL
+    module Collectors
+      # = GraphQL JSON Collector
+      #
       # 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.
+      # front. The drawback is that it can't return a hash.
       class JsonCollector
         def initialize(request)
           @request = request
 
-          @current_value = String.new
+          @current_keys = Set.new
+          @stack_keys = []
+
+          @current_value = StringIO.new
           @stack_value = []
 
           @current_array = false
@@ -30,31 +35,41 @@ module Rails # :nodoc:
           pop_size = array && !plain ? 2 : 1
           @current_value = @stack_value.pop(pop_size).first
           @current_array = @stack_array.pop(pop_size).first
+          @current_keys = @stack_keys.pop
           raise
         end
 
-        # Append to the responsa data all the errors that happened during the
+        # Append to the response data all the errors that happened during the
         # request process.
         def append_errors(errors)
           return if errors.empty?
           add('errors', errors.to_json)
         end
 
+        # Append to the response anything added to the extensions
+        def append_extensions(extensions)
+          return if extensions.empty?
+          add('extensions', extensions.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?
+          (@current_value << ',') if @current_value.pos > 0
+          @current_keys << key
 
           if @current_array
             @current_value << value
           else
-            @current_value << '"'
-            @current_value << key.to_s
-            @current_value << '":'
-            @current_value << value.to_s
+            @current_value << '"' << +key.to_s << '"' << ':' << +value.to_s
           end
         end
 
+        # Check if the given +key+ has been added already
+        def key?(key)
+          @current_keys.include?(key)
+        end
+
         # Same as +add+ but this always encode the +value+ beforehand.
         def safe_add(key, value)
           add(key, value.nil? ? 'null' : value.to_json)
@@ -68,32 +83,42 @@ module Rails # :nodoc:
         # 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 << ',') if @stack_value.last.pos > 0
           @stack_value.last << to_s
-          @current_value = String.new
+
+          @current_value = StringIO.new
+          @current_keys = Set.new
         end
 
         # Get the current result
         def to_s
-          @current_array ? "[#{@current_value}]" : "{#{@current_value}}"
+          if @current_array
+            +'[' << @current_value.string << ']'
+          else
+            +'{' << @current_value.string << '}'
+          end
         end
 
+        alias to_json to_s
+
         private
 
           # Start a new part of the collector. When set +as_array+, the result
-          # of the stack will be encolsed by +[]+.
+          # of the stack will be enclosed by +[]+.
           def start_stack(as_array = false, plain_array = false)
             @stack_value << @current_value
             @stack_array << @current_array
+            @stack_keys << @current_keys
 
             if as_array && !plain_array
-              @stack_value << String.new
+              @stack_value << StringIO.new
               @stack_array << :complex
               as_array = false
             end
 
-            @current_value = String.new
+            @current_value = StringIO.new
             @current_array = as_array
+            @current_keys = Set.new
           end
 
           # Finalize a stack and set the result on the given +key+.
@@ -106,6 +131,7 @@ module Rails # :nodoc:
             result = to_s
             @current_value = @stack_value.pop
             @current_array = @stack_array.pop
+            @current_keys = @stack_keys.pop
             add(key, result)
           end
       end

data/lib/rails/graphql/collectors.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-module Rails # :nodoc:
-  module GraphQL # :nodoc:
-    module Collectors # :nodoc:
+module Rails
+  module GraphQL
+    # All the possible collectors that uses the reverse visit approach
+    module Collectors
       extend ActiveSupport::Autoload
 
       autoload :HashCollector
       autoload :IdentedCollector
       autoload :JsonCollector
-
     end
   end
 end