graphiti 1.2.16 → 1.3.9

data/lib/graphiti/adapters/active_record.rb

@@ -1,7 +1,7 @@
 module Graphiti
   module Adapters
     class ActiveRecord < ::Graphiti::Adapters::Abstract
-      require "graphiti/adapters/active_record/inferrence"
+      require "graphiti/adapters/active_record/inference"
       require "graphiti/adapters/active_record/has_many_sideload"
       require "graphiti/adapters/active_record/belongs_to_sideload"
       require "graphiti/adapters/active_record/has_one_sideload"
@@ -12,31 +12,31 @@ module Graphiti
           has_many: Graphiti::Adapters::ActiveRecord::HasManySideload,
           has_one: Graphiti::Adapters::ActiveRecord::HasOneSideload,
           belongs_to: Graphiti::Adapters::ActiveRecord::BelongsToSideload,
-          many_to_many: Graphiti::Adapters::ActiveRecord::ManyToManySideload,
+          many_to_many: Graphiti::Adapters::ActiveRecord::ManyToManySideload
         }
       end
 
       def filter_eq(scope, attribute, value)
         scope.where(attribute => value)
       end
-      alias filter_integer_eq filter_eq
-      alias filter_float_eq filter_eq
-      alias filter_big_decimal_eq filter_eq
-      alias filter_date_eq filter_eq
-      alias filter_boolean_eq filter_eq
-      alias filter_uuid_eq filter_eq
-      alias filter_enum_eq filter_eq
+      alias_method :filter_integer_eq, :filter_eq
+      alias_method :filter_float_eq, :filter_eq
+      alias_method :filter_big_decimal_eq, :filter_eq
+      alias_method :filter_date_eq, :filter_eq
+      alias_method :filter_boolean_eq, :filter_eq
+      alias_method :filter_uuid_eq, :filter_eq
+      alias_method :filter_enum_eq, :filter_eq
 
       def filter_not_eq(scope, attribute, value)
         scope.where.not(attribute => value)
       end
-      alias filter_integer_not_eq filter_not_eq
-      alias filter_float_not_eq filter_not_eq
-      alias filter_big_decimal_not_eq filter_not_eq
-      alias filter_date_not_eq filter_not_eq
-      alias filter_boolean_not_eq filter_not_eq
-      alias filter_uuid_not_eq filter_not_eq
-      alias filter_enum_not_eq filter_not_eq
+      alias_method :filter_integer_not_eq, :filter_not_eq
+      alias_method :filter_float_not_eq, :filter_not_eq
+      alias_method :filter_big_decimal_not_eq, :filter_not_eq
+      alias_method :filter_date_not_eq, :filter_not_eq
+      alias_method :filter_boolean_not_eq, :filter_not_eq
+      alias_method :filter_uuid_not_eq, :filter_not_eq
+      alias_method :filter_enum_not_eq, :filter_not_eq
 
       def filter_string_eq(scope, attribute, value, is_not: false)
         column = column_for(scope, attribute)
@@ -57,54 +57,63 @@ module Graphiti
         filter_string_eql(scope, attribute, value, is_not: true)
       end
 
-      def filter_string_prefix(scope, attribute, value, is_not: false)
-        column = column_for(scope, attribute)
-        map = value.map { |v| "#{v}%" }
-        clause = column.lower.matches_any(map)
-        is_not ? scope.where.not(clause) : scope.where(clause)
-      end
-
-      def filter_string_not_prefix(scope, attribute, value)
-        filter_string_prefix(scope, attribute, value, is_not: true)
-      end
-
-      def filter_string_suffix(scope, attribute, value, is_not: false)
-        column = column_for(scope, attribute)
-        map = value.map { |v| "%#{v}" }
-        clause = column.lower.matches_any(map)
-        is_not ? scope.where.not(clause) : scope.where(clause)
-      end
-
-      def filter_string_not_suffix(scope, attribute, value)
-        filter_string_suffix(scope, attribute, value, is_not: true)
-      end
-
       # Arel has different match escaping behavior before rails 5.
       # Since rails 4.x does not expose methods to escape LIKE statements
       # anyway, we just don't support proper LIKE escaping in those versions.
-      if ::ActiveRecord.version >= Gem::Version.new('5.0.0')
+      if ::ActiveRecord.version >= Gem::Version.new("5.0.0")
         def filter_string_match(scope, attribute, value, is_not: false)
-          escape_char = '\\'
-          column = column_for(scope, attribute)
-          map = value.map do |v|
-            v = v.downcase
-            v = scope.sanitize_sql_like(v)
+          clause = sanitized_like_for(scope, attribute, value) { |v|
             "%#{v}%"
-          end
-          clause = column.lower.matches_any(map, escape_char, true)
+          }
+          is_not ? scope.where.not(clause) : scope.where(clause)
+        end
+
+        def filter_string_prefix(scope, attribute, value, is_not: false)
+          clause = sanitized_like_for(scope, attribute, value) { |v|
+            "#{v}%"
+          }
+          is_not ? scope.where.not(clause) : scope.where(clause)
+        end
+
+        def filter_string_suffix(scope, attribute, value, is_not: false)
+          clause = sanitized_like_for(scope, attribute, value) { |v|
+            "%#{v}"
+          }
           is_not ? scope.where.not(clause) : scope.where(clause)
         end
       else
         def filter_string_match(scope, attribute, value, is_not: false)
           column = column_for(scope, attribute)
-          map = value.map do |v|
+          map = value.map { |v|
             "%#{v.downcase}%"
-          end
+          }
+          clause = column.lower.matches_any(map)
+          is_not ? scope.where.not(clause) : scope.where(clause)
+        end
+
+        def filter_string_prefix(scope, attribute, value, is_not: false)
+          column = column_for(scope, attribute)
+          map = value.map { |v| "#{v}%" }
+          clause = column.lower.matches_any(map)
+          is_not ? scope.where.not(clause) : scope.where(clause)
+        end
+
+        def filter_string_suffix(scope, attribute, value, is_not: false)
+          column = column_for(scope, attribute)
+          map = value.map { |v| "%#{v}" }
           clause = column.lower.matches_any(map)
           is_not ? scope.where.not(clause) : scope.where(clause)
         end
       end
 
+      def filter_string_not_prefix(scope, attribute, value)
+        filter_string_prefix(scope, attribute, value, is_not: true)
+      end
+
+      def filter_string_not_suffix(scope, attribute, value)
+        filter_string_suffix(scope, attribute, value, is_not: true)
+      end
+
       def filter_string_not_match(scope, attribute, value)
         filter_string_match(scope, attribute, value, is_not: true)
       end
@@ -113,44 +122,44 @@ module Graphiti
         column = column_for(scope, attribute)
         scope.where(column.gt_any(value))
       end
-      alias filter_integer_gt filter_gt
-      alias filter_float_gt filter_gt
-      alias filter_big_decimal_gt filter_gt
-      alias filter_datetime_gt filter_gt
-      alias filter_date_gt filter_gt
+      alias_method :filter_integer_gt, :filter_gt
+      alias_method :filter_float_gt, :filter_gt
+      alias_method :filter_big_decimal_gt, :filter_gt
+      alias_method :filter_datetime_gt, :filter_gt
+      alias_method :filter_date_gt, :filter_gt
 
       def filter_gte(scope, attribute, value)
         column = column_for(scope, attribute)
         scope.where(column.gteq_any(value))
       end
-      alias filter_integer_gte filter_gte
-      alias filter_float_gte filter_gte
-      alias filter_big_decimal_gte filter_gte
-      alias filter_datetime_gte filter_gte
-      alias filter_date_gte filter_gte
+      alias_method :filter_integer_gte, :filter_gte
+      alias_method :filter_float_gte, :filter_gte
+      alias_method :filter_big_decimal_gte, :filter_gte
+      alias_method :filter_datetime_gte, :filter_gte
+      alias_method :filter_date_gte, :filter_gte
 
       def filter_lt(scope, attribute, value)
         column = column_for(scope, attribute)
         scope.where(column.lt_any(value))
       end
-      alias filter_integer_lt filter_lt
-      alias filter_float_lt filter_lt
-      alias filter_big_decimal_lt filter_lt
-      alias filter_datetime_lt filter_lt
-      alias filter_date_lt filter_lt
+      alias_method :filter_integer_lt, :filter_lt
+      alias_method :filter_float_lt, :filter_lt
+      alias_method :filter_big_decimal_lt, :filter_lt
+      alias_method :filter_datetime_lt, :filter_lt
+      alias_method :filter_date_lt, :filter_lt
 
       def filter_lte(scope, attribute, value)
         column = column_for(scope, attribute)
         scope.where(column.lteq_any(value))
       end
-      alias filter_integer_lte filter_lte
-      alias filter_float_lte filter_lte
-      alias filter_big_decimal_lte filter_lte
-      alias filter_date_lte filter_lte
+      alias_method :filter_integer_lte, :filter_lte
+      alias_method :filter_float_lte, :filter_lte
+      alias_method :filter_big_decimal_lte, :filter_lte
+      alias_method :filter_date_lte, :filter_lte
 
       # Ensure fractional seconds don't matter
       def filter_datetime_eq(scope, attribute, value, is_not: false)
-        ranges = value.map { |v| (v..v + 1.second - 0.00000001) }
+        ranges = value.map { |v| (v..v + 1.second - 0.00000001) unless v.nil? }
         clause = {attribute => ranges}
         is_not ? scope.where.not(clause) : scope.where(clause)
       end
@@ -175,14 +184,17 @@ module Graphiti
       end
 
       # (see Adapters::Abstract#paginate)
-      def paginate(scope, current_page, per_page)
-        scope.page(current_page).per(per_page)
+      def paginate(scope, current_page, per_page, offset)
+        scope = scope.page(current_page) if current_page
+        scope = scope.per(per_page) if per_page
+        scope = scope.padding(offset) if offset
+        scope
       end
 
       # (see Adapters::Abstract#count)
       def count(scope, attr)
         if attr.to_sym == :total
-          scope.distinct.count
+          scope.distinct.count(:all)
         else
           scope.distinct.count(attr)
         end
@@ -231,7 +243,8 @@ module Graphiti
           children.each do |child|
             if association_type == :many_to_many &&
                 [:create, :update].include?(Graphiti.context[:namespace]) &&
-                !parent.send(association_name).exists?(child.id)
+                !parent.send(association_name).exists?(child.id) &&
+                child.errors.blank?
               parent.send(association_name) << child
             else
               target = association.instance_variable_get(:@target)
@@ -273,8 +286,8 @@ module Graphiti
 
       # (see Adapters::Abstract#update)
       def update(model_class, update_params)
-        instance = model_class.find(update_params.delete(:id))
-        instance.update_attributes(update_params)
+        instance = model_class.find(update_params.only(:id))
+        instance.update_attributes(update_params.except(:id))
         instance
       end
 
@@ -288,6 +301,18 @@ module Graphiti
         model_instance
       end
 
+      def close
+        ::ActiveRecord::Base.clear_active_connections!
+      end
+
+      def can_group?
+        true
+      end
+
+      def group(scope, attribute)
+        scope.group(attribute)
+      end
+
       private
 
       def column_for(scope, name)
@@ -298,6 +323,26 @@ module Graphiti
           table[name]
         end
       end
+
+      def sanitized_like_for(scope, attribute, value, &block)
+        escape_char = "\\"
+        column = column_for(scope, attribute)
+        map = value.map { |v|
+          v = v.downcase
+          v = Sanitizer.sanitize_like(v, escape_char)
+          block.call v
+        }
+
+        column.lower.matches_any(map, escape_char, true)
+      end
+
+      class Sanitizer
+        extend ::ActiveRecord::Sanitization::ClassMethods
+
+        def self.sanitize_like(*args)
+          sanitize_sql_like(*args)
+        end
+      end
     end
   end
 end

data/lib/graphiti/adapters/graphiti_api.rb

@@ -34,7 +34,7 @@ module Graphiti
 
       def build_url(scope)
         url = resource.remote_url
-        params = scope[:params].merge(scope.except(:params))
+        params = scope[:params].merge(scope.except(:params, :foreign_key))
         params[:page] ||= {}
         params[:page][:size] ||= 999
         params = CGI.unescape(params.to_query)

data/lib/graphiti/adapters/null.rb

@@ -178,7 +178,7 @@ module Graphiti
       end
 
       # (see Adapters::Abstract#paginate)
-      def paginate(scope, current_page, per_page)
+      def paginate(scope, current_page, per_page, offset)
         scope
       end
 

data/lib/graphiti/adapters/persistence/associations.rb

@@ -0,0 +1,78 @@
+module Graphiti
+  module Adapters
+    module Persistence
+      module Associations
+        def process_belongs_to(persistence, attributes)
+          parents = [].tap do |processed|
+            persistence.iterate(only: [:polymorphic_belongs_to, :belongs_to]) do |x|
+              id = x.dig(:attributes, :id)
+              x[:object] = x[:resource]
+                .persist_with_relationships(x[:meta], x[:attributes], x[:relationships])
+              processed << x
+            rescue Graphiti::Errors::RecordNotFound
+              if Graphiti.config.raise_on_missing_sidepost
+                path = "relationships/#{x.dig(:meta, :jsonapi_type)}"
+                raise Graphiti::Errors::RecordNotFound.new(x[:sideload].name, id, path)
+              else
+                pointer = "data/relationships/#{x.dig(:meta, :jsonapi_type)}"
+                object = Graphiti::Errors::NullRelation.new(id.to_s, pointer)
+                object.errors.add(:base, :not_found, message: "could not be found")
+                x[:object] = object
+                processed << x
+              end
+            end
+          end
+
+          update_foreign_key_for_parents(parents, attributes)
+          parents
+        end
+
+        def process_has_many(persistence, caller_model)
+          [].tap do |processed|
+            persistence.iterate(except: [:polymorphic_belongs_to, :belongs_to]) do |x|
+              update_foreign_key(caller_model, x[:attributes], x)
+
+              x[:object] = x[:resource]
+                .persist_with_relationships(x[:meta], x[:attributes], x[:relationships], caller_model, x[:foreign_key])
+
+              processed << x
+            end
+          end
+        end
+
+        def update_foreign_key_for_parents(parents, attributes)
+          parents.each do |x|
+            update_foreign_key(x[:object], attributes, x)
+          end
+        end
+
+        # The child's attributes should be modified to nil-out the
+        # foreign_key when the parent is being destroyed or disassociated
+        #
+        # This is not the case for HABTM, whose "foreign key" is a join table
+        def update_foreign_key(parent_object, attrs, x)
+          return if x[:sideload].type == :many_to_many
+
+          if [:destroy, :disassociate].include?(x[:meta][:method])
+            if x[:sideload].polymorphic_has_one? || x[:sideload].polymorphic_has_many?
+              attrs[:"#{x[:sideload].polymorphic_as}_type"] = nil
+            end
+            attrs[x[:foreign_key]] = nil
+            update_foreign_type(attrs, x, null: true) if x[:is_polymorphic]
+          else
+            if x[:sideload].polymorphic_has_one? || x[:sideload].polymorphic_has_many?
+              attrs[:"#{x[:sideload].polymorphic_as}_type"] = parent_object.class.name
+            end
+            attrs[x[:foreign_key]] = parent_object.send(x[:primary_key])
+            update_foreign_type(attrs, x) if x[:is_polymorphic]
+          end
+        end
+
+        def update_foreign_type(attrs, x, null: false)
+          grouping_field = x[:sideload].parent.grouper.field_name
+          attrs[grouping_field] = null ? nil : x[:sideload].group_name
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/configuration.rb

@@ -14,6 +14,7 @@ module Graphiti
     attr_accessor :pagination_links_on_demand
     attr_accessor :pagination_links
     attr_accessor :typecast_reads
+    attr_accessor :raise_on_missing_sidepost
 
     attr_reader :debug, :debug_models
 
@@ -29,6 +30,7 @@ module Graphiti
       @pagination_links_on_demand = false
       @pagination_links = false
       @typecast_reads = true
+      @raise_on_missing_sidepost = true
       self.debug = ENV.fetch("GRAPHITI_DEBUG", true)
       self.debug_models = ENV.fetch("GRAPHITI_DEBUG_MODELS", false)
 
@@ -43,7 +45,7 @@ module Graphiti
         end
 
         if (logger = ::Rails.logger)
-          self.debug = logger.level.zero? && self.debug
+          self.debug = logger.debug? && debug
           Graphiti.logger = logger
         end
       end

data/lib/graphiti/debugger.rb

@@ -10,6 +10,8 @@ module Graphiti
 
     class << self
       def on_data(name, start, stop, id, payload)
+        return [] unless enabled
+
         took = ((stop - start) * 1000.0).round(2)
         params = scrub_params(payload[:params])
 
@@ -24,7 +26,7 @@ module Graphiti
         end
       end
 
-      def on_data_exception(payload, params)
+      private def on_data_exception(payload, params)
         unless payload[:exception_object].instance_variable_get(:@__graphiti_debug)
           add_chunk do |logs, json|
             logs << ["\n=== Graphiti Debug ERROR", :red, true]
@@ -49,20 +51,20 @@ module Graphiti
         end
       end
 
-      def results(raw_results)
+      private def results(raw_results)
         raw_results.map { |r| "[#{r.class.name}, #{r.id.inspect}]" }.join(", ")
       end
 
-      def on_sideload_data(payload, params, took)
+      private def on_sideload_data(payload, params, took)
         sideload = payload[:sideload]
         results = results(payload[:results])
         add_chunk(payload[:resource], payload[:parent]) do |logs, json|
           logs << [" \\_ #{sideload.name}", :yellow, true]
           json[:name] = sideload.name
-          if sideload.class.scope_proc
-            query = "#{payload[:resource].class.name}: Manual sideload via .scope"
+          query = if sideload.class.scope_proc
+            "#{payload[:resource].class.name}: Manual sideload via .scope"
           else
-            query = "#{payload[:resource].class.name}.all(#{params.inspect})"
+            "#{payload[:resource].class.name}.all(#{params.inspect})"
           end
           logs << ["    #{query}", :cyan, true]
           json[:query] = query
@@ -72,7 +74,7 @@ module Graphiti
         end
       end
 
-      def on_primary_data(payload, params, took)
+      private def on_primary_data(payload, params, took)
         results = results(payload[:results])
         add_chunk(payload[:resource], payload[:parent]) do |logs, json|
           logs << [""]
@@ -90,6 +92,8 @@ module Graphiti
       end
 
       def on_render(name, start, stop, id, payload)
+        return [] unless enabled
+
         add_chunk do |logs|
           took = ((stop - start) * 1000.0).round(2)
           logs << [""]
@@ -148,7 +152,7 @@ module Graphiti
           parent: parent,
           logs: logs,
           json: json,
-          children: [],
+          children: []
         }
       end
 

data/lib/graphiti/delegates/pagination.rb

@@ -6,32 +6,48 @@ module Graphiti
       end
 
       def links?
-        @proxy.query.pagination_links?
+        @proxy.query.pagination_links? && @proxy.data.present?
       end
 
       def links
         @links ||= {}.tap do |links|
+          links[:self] = pagination_link(current_page)
           links[:first] = pagination_link(1)
           links[:last] = pagination_link(last_page)
-          links[:prev] = pagination_link(current_page - 1) unless current_page == 1
-          links[:next] = pagination_link(current_page + 1) unless current_page == last_page
-        end.select {|k, v| !v.nil? }
+          links[:prev] = pagination_link(current_page - 1) if has_previous_page?
+          links[:next] = pagination_link(current_page + 1) if has_next_page?
+        end.select { |k, v| !v.nil? }
+      end
+
+      def has_next_page?
+        current_page != last_page && last_page.present?
+      end
+
+      def has_previous_page?
+        current_page != 1 ||
+          !!pagination_params.try(:[], :page).try(:[], :after) ||
+          !!pagination_params.try(:[], :page).try(:[], :offset)
       end
 
       private
 
+      def pagination_params
+        @pagination_params ||= @proxy.query.params.reject { |key, _| [:action, :controller, :format].include?(key) }
+      end
+
       def pagination_link(page)
         return nil unless @proxy.resource.endpoint
 
         uri = URI(@proxy.resource.endpoint[:url].to_s)
 
+        page_params = {
+          number: page,
+          size: page_size
+        }
+        page_params[:offset] = offset if offset
+
         # Overwrite the pagination query params with the desired page
-        uri.query = @proxy.query.hash.merge({
-          page: {
-            number: page,
-            size: page_size,
-          },
-        }).to_query
+        uri.query = pagination_params.merge(page: page_params).to_query
         uri.to_s
       end
 
@@ -41,15 +57,18 @@ module Graphiti
         elsif page_size == 0 || item_count == 0
           return nil
         end
-        @last_page = (item_count / page_size)
-        @last_page += 1 if item_count % page_size > 0
+
+        count = item_count
+        count = item_count - offset if offset
+        @last_page = (count / page_size)
+        @last_page += 1 if count % page_size > 0
         @last_page
       end
 
       def item_count
         begin
           return @item_count if @item_count
-          @item_count = @proxy.resource.stat(:total, :count).call(@proxy.scope.unpaginated_object, :total)
+          @item_count = item_count_from_proxy || item_count_from_stats
           unless @item_count.is_a?(Numeric)
             raise TypeError, "#{@proxy.resource}.stat(:total, :count) returned an invalid value #{@item_count}"
           end
@@ -64,10 +83,25 @@ module Graphiti
         @item_count
       end
 
+      def item_count_from_proxy
+        @proxy.stats.dig(:total, :count)
+      end
+
+      def item_count_from_stats
+        stats = Stats::Payload.new(@proxy.resource, @proxy.query, @proxy.scope.unpaginated_object, @proxy.data)
+        stats.calculate_stat(:total, @proxy.resource.stat(:total, :count))
+      end
+
       def current_page
         @current_page ||= (page_param[:number] || 1).to_i
       end
 
+      def offset
+        @offset ||= if (value = page_param[:offset])
+          value.to_i
+        end
+      end
+
       def page_size
         @page_size ||= (page_param[:size] ||
                         @proxy.resource.default_page_size ||

data/lib/graphiti/deserializer.rb

@@ -87,7 +87,7 @@ class Graphiti::Deserializer
       type: data[:type],
       temp_id: data[:'temp-id'],
       method: action,
-      payload_path: ["data"],
+      payload_path: ["data"]
     }
   end
 
@@ -185,10 +185,10 @@ class Graphiti::Deserializer
         jsonapi_type: datum[:type],
         temp_id: temp_id,
         method: method,
-        payload_path: ["included", included_idx],
+        payload_path: ["included", included_idx]
       },
       attributes: attributes,
-      relationships: relationships,
+      relationships: relationships
     }
   end