graphiti 1.2.44 → 1.3.9

data/lib/graphiti/hash_renderer.rb

@@ -101,6 +101,10 @@ module Graphiti
           hash[:_type] = jsonapi_type.to_s
         end
 
+        if (fields_list || []).include?(:_cursor)
+          hash[:_cursor] = cursor
+        end
+
         if (fields_list || []).include?(:__typename)
           resource_class = @resource.class
           if polymorphic_subclass?
@@ -142,6 +146,10 @@ module Graphiti
       nodes = get_nodes(serializers, opts)
       add_nodes(hash, top_level_key, options, nodes, @graphql)
       add_stats(hash, top_level_key, options, @graphql)
+      if @graphql
+        add_page_info(hash, serializers, top_level_key, options)
+      end
+
       hash
     end
 
@@ -160,7 +168,7 @@ module Graphiti
 
     def get_nodes(serializers, opts)
       if serializers.is_a?(Array)
-        serializers.map do |s|
+        serializers.each_with_index.map do |s, index|
           s.to_hash(**opts)
         end
       else
@@ -184,12 +192,42 @@ module Graphiti
       if options[:meta] && !options[:meta].empty?
         if @graphql
           if (stats = options[:meta][:stats])
-            hash[top_level_key][:stats] = stats
+            camelized = {}
+            stats.each_pair do |key, value|
+              camelized[key.to_s.camelize(:lower).to_sym] = value
+            end
+            hash[top_level_key][:stats] = camelized
           end
         else
           hash.merge!(options.slice(:meta))
         end
       end
     end
+
+    # NB - this is only for top-level right now
+    # The casing here is GQL-specific, we can update later if needed.
+    def add_page_info(hash, serializers, top_level_key, options)
+      if (fields = options[:fields].try(:[], :page_info))
+        info = {}
+
+        if fields.include?(:has_next_page)
+          info[:hasNextPage] = options[:proxy].pagination.has_next_page?
+        end
+
+        if fields.include?(:has_previous_page)
+          info[:hasPreviousPage] = options[:proxy].pagination.has_previous_page?
+        end
+
+        if fields.include?(:start_cursor)
+          info[:startCursor] = serializers.first.try(:cursor)
+        end
+
+        if fields.include?(:end_cursor)
+          info[:endCursor] = serializers.last.try(:cursor)
+        end
+
+        hash[top_level_key][:pageInfo] = info
+      end
+    end
   end
 end

data/lib/graphiti/query.rb

@@ -69,11 +69,9 @@ module Graphiti
     end
 
     def sideload_hash
-      @sideload_hash = begin
-        {}.tap do |hash|
-          sideloads.each_pair do |key, value|
-            hash[key] = sideloads[key].hash
-          end
+      @sideload_hash = {}.tap do |hash|
+        sideloads.each_pair do |key, value|
+          hash[key] = sideloads[key].hash
         end
       end
     end
@@ -89,30 +87,28 @@ module Graphiti
     end
 
     def sideloads
-      @sideloads ||= begin
-        {}.tap do |hash|
-          include_hash.each_pair do |key, sub_hash|
-            sideload = @resource.class.sideload(key)
-
-            if sideload || @resource.remote?
-              sl_resource = resource_for_sideload(sideload)
-              query_parents = parents + [self]
-              sub_hash = sub_hash[:include] if sub_hash.key?(:include)
-
-              # NB: To handle on__<type>--<name>
-              # A) relationship_name == :positions
-              # B) key == on__employees.positions
-              # This way A) ensures sideloads are resolved
-              # And B) ensures nested filters, sorts etc still work
-              relationship_name = sideload ? sideload.name : key
-              hash[relationship_name] = Query.new sl_resource,
-                @params,
-                key,
-                sub_hash,
-                query_parents, :all
-            else
-              handle_missing_sideload(key)
-            end
+      @sideloads ||= {}.tap do |hash|
+        include_hash.each_pair do |key, sub_hash|
+          sideload = @resource.class.sideload(key)
+
+          if sideload || @resource.remote?
+            sl_resource = resource_for_sideload(sideload)
+            query_parents = parents + [self]
+            sub_hash = sub_hash[:include] if sub_hash.key?(:include)
+
+            # NB: To handle on__<type>--<name>
+            # A) relationship_name == :positions
+            # B) key == on__employees.positions
+            # This way A) ensures sideloads are resolved
+            # And B) ensures nested filters, sorts etc still work
+            relationship_name = sideload ? sideload.name : key
+            hash[relationship_name] = Query.new sl_resource,
+              @params,
+              key,
+              sub_hash,
+              query_parents, :all
+          else
+            handle_missing_sideload(key)
           end
         end
       end
@@ -137,27 +133,25 @@ module Graphiti
     end
 
     def filters
-      @filters ||= begin
-        {}.tap do |hash|
-          (@params[:filter] || {}).each_pair do |name, value|
-            name = name.to_sym
-
-            if legacy_nested?(name)
-              value.keys.each do |key|
-                filter_name = key.to_sym
-                filter_value = value[key]
-
-                if @resource.get_attr!(filter_name, :filterable, request: true)
-                  hash[filter_name] = filter_value
-                end
+      @filters ||= {}.tap do |hash|
+        (@params[:filter] || {}).each_pair do |name, value|
+          name = name.to_sym
+
+          if legacy_nested?(name)
+            value.keys.each do |key|
+              filter_name = key.to_sym
+              filter_value = value[key]
+
+              if @resource.get_attr!(filter_name, :filterable, request: true)
+                hash[filter_name] = filter_value
               end
-            elsif nested?(name)
-              name = name.to_s.split(".").last.to_sym
-              validate!(name, :filterable)
-              hash[name] = value
-            elsif top_level? && validate!(name, :filterable)
-              hash[name] = value
             end
+          elsif nested?(name)
+            name = name.to_s.split(".").last.to_sym
+            validate!(name, :filterable)
+            hash[name] = value
+          elsif top_level? && validate!(name, :filterable)
+            hash[name] = value
           end
         end
       end
@@ -186,18 +180,17 @@ module Graphiti
     end
 
     def pagination
-      @pagination ||= begin
-        {}.tap do |hash|
-          (@params[:page] || {}).each_pair do |name, value|
-            if legacy_nested?(name)
-              value.each_pair do |k, v|
-                hash[k.to_sym] = v.to_i
-              end
-            elsif nested?(name)
-              hash[name.to_s.split(".").last.to_sym] = value
-            elsif top_level? && [:number, :size, :offset].include?(name.to_sym)
-              hash[name.to_sym] = value.to_i
+      @pagination ||= {}.tap do |hash|
+        (@params[:page] || {}).each_pair do |name, value|
+          if legacy_nested?(name)
+            value.each_pair do |k, v|
+              hash[k.to_sym] = cast_page_param(k.to_sym, v)
             end
+          elsif nested?(name)
+            param_name = name.to_s.split(".").last.to_sym
+            hash[param_name] = cast_page_param(param_name, value)
+          elsif top_level? && Scoping::Paginate::PARAMS.include?(name.to_sym)
+            hash[name.to_sym] = cast_page_param(name.to_sym, value)
           end
         end
       end
@@ -220,15 +213,13 @@ module Graphiti
     end
 
     def stats
-      @stats ||= begin
-        {}.tap do |hash|
-          (@params[:stats] || {}).each_pair do |k, v|
-            if legacy_nested?(k)
-              raise NotImplementedError.new("Association statistics are not currently supported")
-            elsif top_level?
-              v = v.split(",") if v.is_a?(String)
-              hash[k.to_sym] = Array(v).flatten.map(&:to_sym)
-            end
+      @stats ||= {}.tap do |hash|
+        (@params[:stats] || {}).each_pair do |k, v|
+          if legacy_nested?(k)
+            raise NotImplementedError.new("Association statistics are not currently supported")
+          elsif top_level?
+            v = v.split(",") if v.is_a?(String)
+            hash[k.to_sym] = Array(v).flatten.map(&:to_sym)
           end
         end
       end
@@ -240,6 +231,18 @@ module Graphiti
 
     private
 
+    def cast_page_param(name, value)
+      if [:before, :after].include?(name)
+        decode_cursor(value)
+      else
+        value.to_i
+      end
+    end
+
+    def decode_cursor(cursor)
+      JSON.parse(Base64.decode64(cursor)).symbolize_keys
+    end
+
     # Try to find on this resource
     # If not there, follow the legacy logic of scalling all other
     # resource names/types

data/lib/graphiti/railtie.rb

@@ -110,10 +110,10 @@ module Graphiti
         end
 
         route = begin
-                  ::Rails.application.routes.recognize_path(path, method: method)
-                rescue
-                  nil
-                end
+          ::Rails.application.routes.recognize_path(path, method: method)
+        rescue
+          nil
+        end
         "#{route[:controller]}_controller".classify.safe_constantize if route
       }
     end

data/lib/graphiti/renderer.rb

@@ -66,6 +66,7 @@ module Graphiti
         options[:meta] ||= proxy.meta
         options[:meta][:stats] = proxy.stats unless proxy.stats.empty?
         options[:meta][:debug] = Debugger.to_a if debug_json?
+        options[:proxy] = proxy
 
         renderer.render(records, options)
       end

data/lib/graphiti/request_validator.rb

@@ -13,7 +13,7 @@ module Graphiti
     class ValidatorFactory
       def self.create(root_resource, raw_params, action)
         case action
-        when :update then
+        when :update
           RequestValidators::UpdateValidator
         else
           RequestValidators::Validator

data/lib/graphiti/resource/configuration.rb

@@ -92,7 +92,8 @@ module Graphiti
           :relationships_writable_by_default,
           :filters_accept_nil_by_default,
           :filters_deny_empty_by_default,
-          :graphql_entrypoint
+          :graphql_entrypoint,
+          :cursor_paginatable
 
         class << self
           prepend Overrides

data/lib/graphiti/resource/dsl.rb

@@ -9,7 +9,11 @@ module Graphiti
           opts = args.extract_options!
           type_override = args[0]
 
-          if (att = get_attr(name, :filterable, raise_error: :only_unsupported))
+          if (att = (attributes[name] || extra_attributes[name]))
+            # We're opting in to filtering, so force this
+            # UNLESS the filter is guarded at the attribute level
+            att[:filterable] = true if att[:filterable] == false
+
             aliases = [name, opts[:aliases]].flatten.compact
             operators = FilterOperators.build(self, att[:type], opts, &blk)
 
@@ -23,6 +27,8 @@ module Graphiti
             end
 
             required = att[:filterable] == :required || !!opts[:required]
+            schema = !!opts[:via_attribute_dsl] ? att[:schema] : opts[:schema] != false
+
             config[:filters][name.to_sym] = {
               aliases: aliases,
               name: name.to_sym,
@@ -32,6 +38,7 @@ module Graphiti
               single: !!opts[:single],
               dependencies: opts[:dependent],
               required: required,
+              schema: schema,
               operators: operators.to_hash,
               allow_nil: opts.fetch(:allow_nil, filters_accept_nil_by_default),
               deny_empty: opts.fetch(:deny_empty, filters_deny_empty_by_default)
@@ -56,7 +63,7 @@ module Graphiti
         end
 
         def sort_all(&blk)
-          if block_given?
+          if blk
             config[:_sort_all] = blk
           else
             config[:_sort_all]
@@ -130,7 +137,7 @@ module Graphiti
           options[:sortable] ? sort(name) : config[:sorts].delete(name)
 
           if options[:filterable]
-            filter(name, allow: options[:allow])
+            filter(name, allow: options[:allow], via_attribute_dsl: true)
           else
             config[:filters].delete(name)
           end
@@ -144,7 +151,8 @@ module Graphiti
             readable: true,
             writable: false,
             sortable: false,
-            filterable: false
+            filterable: false,
+            schema: true
           }
           options = defaults.merge(options)
           attribute_option(options, :readable)
@@ -181,9 +189,9 @@ module Graphiti
         def attribute_option(options, name, exclusive = false)
           if options[name] != false
             default = if (only = options[:only]) && !exclusive
-              Array(only).include?(name) ? true : false
+              Array(only).include?(name)
             elsif (except = options[:except]) && !exclusive
-              Array(except).include?(name) ? false : true
+              !Array(except).include?(name)
             else
               send(:"attributes_#{name}_by_default")
             end

data/lib/graphiti/resource/polymorphism.rb

@@ -72,7 +72,7 @@ module Graphiti
         end
 
         def resource_for_model(model)
-          resource = children.find { |c| model.class == c.model } ||
+          resource = children.find { |c| model.instance_of?(c.model) } ||
             children.find { |c| model.is_a?(c.model) }
           if resource.nil?
             raise Errors::PolymorphicResourceChildNotFound.new(self, model: model)

data/lib/graphiti/resource/sideloading.rb

@@ -68,10 +68,10 @@ module Graphiti
           model_ref = model
           has_many name, opts do
             params do |hash|
-              hash[:filter][:"#{as}_type"] = model_ref.name
+              hash[:filter][:"#{as}_type"] = { eql: model_ref.name }
             end
 
-            instance_eval(&blk) if block_given?
+            instance_eval(&blk) if blk
           end
         end
 
@@ -82,10 +82,10 @@ module Graphiti
           model_ref = model
           has_one name, opts do
             params do |hash|
-              hash[:filter][:"#{as}_type"] = model_ref.name
+              hash[:filter][:"#{as}_type"] = { eql: model_ref.name }
             end
 
-            instance_eval(&blk) if block_given?
+            instance_eval(&blk) if blk
           end
         end
 

data/lib/graphiti/resource.rb

@@ -28,11 +28,12 @@ module Graphiti
       serializer
     end
 
-    def decorate_record(record)
+    def decorate_record(record, index = nil)
       unless record.instance_variable_get(:@__graphiti_serializer)
         serializer = serializer_for(record)
         record.instance_variable_set(:@__graphiti_serializer, serializer)
         record.instance_variable_set(:@__graphiti_resource, self)
+        record.instance_variable_set(:@__graphiti_index, index) if index
       end
     end
 

data/lib/graphiti/resource_proxy.rb

@@ -73,7 +73,7 @@ module Graphiti
         records
       end
     end
-    alias to_a data
+    alias_method :to_a, :data
 
     def meta
       @meta ||= data.respond_to?(:meta) ? data.meta : {}
@@ -85,9 +85,15 @@ module Graphiti
 
     def stats
       @stats ||= if @query.hash[:stats]
+        scope = @scope.unpaginated_object
+        if resource.adapter.can_group?
+          if (group = @query.hash[:stats].delete(:group_by))
+            scope = resource.adapter.group(scope, group[0])
+          end
+        end
         payload = Stats::Payload.new @resource,
           @query,
-          @scope.unpaginated_object,
+          scope,
           data
         payload.generate
       else

data/lib/graphiti/schema.rb

@@ -153,6 +153,8 @@ module Graphiti
     def extra_attributes(resource)
       {}.tap do |attrs|
         resource.extra_attributes.each_pair do |name, config|
+          next unless config[:schema]
+
           attrs[name] = {
             type: config[:type].to_s,
             readable: flag(config[:readable]),
@@ -181,11 +183,11 @@ module Graphiti
     def sorts(resource)
       {}.tap do |s|
         resource.sorts.each_pair do |name, sort|
-          next unless resource.attributes[name][:schema]
+          attr = resource.all_attributes[name]
+          next unless attr[:schema]
 
           config = {}
           config[:only] = sort[:only] if sort[:only]
-          attr = resource.attributes[name]
           if attr[:sortable].is_a?(Symbol)
             config[:guard] = true
           end
@@ -197,7 +199,7 @@ module Graphiti
     def filters(resource)
       {}.tap do |f|
         resource.filters.each_pair do |name, filter|
-          next unless resource.attributes[name][:schema]
+          next unless resource.filters[name][:schema]
 
           config = {
             type: filter[:type].to_s,
@@ -209,7 +211,7 @@ module Graphiti
           config[:deny] = filter[:deny].map(&:to_s) if filter[:deny]
           config[:dependencies] = filter[:dependencies].map(&:to_s) if filter[:dependencies]
 
-          attr = resource.attributes[name]
+          attr = resource.all_attributes[name]
           if attr[:filterable].is_a?(Symbol)
             if attr[:filterable] == :required
               config[:required] = true

data/lib/graphiti/scope.rb

@@ -85,8 +85,8 @@ module Graphiti
     # Used to ensure the resource's serializer is used
     # Not one derived through the usual jsonapi-rb logic
     def assign_serializer(records)
-      records.each do |r|
-        @resource.decorate_record(r)
+      records.each_with_index do |r, index|
+        @resource.decorate_record(r, index)
       end
     end
 

data/lib/graphiti/scoping/paginate.rb

@@ -1,6 +1,7 @@
 module Graphiti
   class Scoping::Paginate < Scoping::Base
     DEFAULT_PAGE_SIZE = 20
+    PARAMS = [:number, :size, :offset, :before, :after]
 
     def apply
       if size > resource.max_page_size
@@ -56,7 +57,7 @@ module Graphiti
     private
 
     def requested?
-      ![page_param[:size], page_param[:number]].all?(&:nil?)
+      !PARAMS.map { |p| page_param[p] }.all?(&:nil?)
     end
 
     def page_param
@@ -64,9 +65,34 @@ module Graphiti
     end
 
     def offset
+      offset = nil
+
       if (value = page_param[:offset])
-        value.to_i
+        offset = value.to_i
+      end
+
+      if before_cursor&.key?(:offset)
+        if page_param.key?(:number)
+          raise Errors::UnsupportedBeforeCursor
+        end
+
+        offset = before_cursor[:offset] - (size * number) - 1
+        offset = 0 if offset.negative?
+      end
+
+      if after_cursor&.key?(:offset)
+        offset = after_cursor[:offset]
       end
+
+      offset
+    end
+
+    def after_cursor
+      page_param[:after]
+    end
+
+    def before_cursor
+      page_param[:before]
     end
 
     def number

data/lib/graphiti/scoping/sort.rb

@@ -59,12 +59,10 @@ module Graphiti
     end
 
     def sort_param
-      @sort_param ||= begin
-        if query_hash[:sort].blank?
-          resource.default_sort || []
-        else
-          normalize(query_hash[:sort])
-        end
+      @sort_param ||= if query_hash[:sort].blank?
+        resource.default_sort || []
+      else
+        normalize(query_hash[:sort])
       end
     end
 

data/lib/graphiti/serializer.rb

@@ -25,8 +25,9 @@ module Graphiti
 
         # See #requested_relationships
         def self.relationship(name, options = {}, &block)
+          prev = Util::Hash.deep_dup(field_condition_blocks)
           super
-          field_condition_blocks.delete(name)
+          self.field_condition_blocks = prev
           _register_condition(relationship_condition_blocks, name, options)
         end
 
@@ -45,6 +46,23 @@ module Graphiti
       end
     end
 
+    def cursor
+      starting_offset = 0
+      page_param = @proxy.query.pagination
+      if (page_number = page_param[:number])
+        page_size = page_param[:size] || @resource.default_page_size
+        starting_offset = (page_number - 1) * page_size
+      end
+
+      if (cursor = page_param[:after])
+        starting_offset = cursor[:offset]
+      end
+
+      current_offset = @object.instance_variable_get(:@__graphiti_index)
+      offset = starting_offset + current_offset + 1 # (+ 1 b/c o-base index)
+      Base64.encode64({offset: offset}.to_json).chomp
+    end
+
     def as_jsonapi(kwargs = {})
       super(**kwargs).tap do |hash|
         strip_relationships!(hash) if strip_relationships?

data/lib/graphiti/sideload/polymorphic_belongs_to.rb

@@ -7,7 +7,6 @@ class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
       @calls = []
     end
 
-    # rubocop: disable Style/MethodMissingSuper
     def method_missing(name, *args, &blk)
       @calls << [name, args, blk]
     end
@@ -56,9 +55,9 @@ class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
           args = call[1]
           opts = args.extract_options!
           opts.merge! as: sideload.name,
-                      parent: sideload,
-                      group_name: group.name,
-                      polymorphic_child: true
+            parent: sideload,
+            group_name: group.name,
+            polymorphic_child: true
           unless sideload.resource.class.abstract_class?
             opts[:foreign_key] ||= sideload.foreign_key
             opts[:primary_key] ||= sideload.primary_key

data/lib/graphiti/stats/dsl.rb

@@ -46,7 +46,6 @@ module Graphiti
       #
       # ...will hit +method_missing+ and store the proc for future reference.
       # @api private
-      # rubocop: disable Style/MethodMissingSuper
       def method_missing(meth, *args, &blk)
         @calculations[meth] = blk
       end

data/lib/graphiti/util/serializer_attributes.rb

@@ -28,6 +28,12 @@ module Graphiti
 
         existing = @serializer.send(applied_method)
         @serializer.send(:"#{applied_method}=", [@name] | existing)
+
+        @serializer.meta do
+          if !!@resource.try(:cursor_paginatable?) && !Graphiti.context[:graphql]
+            {cursor: cursor}
+          end
+        end
       end
 
       private