graphiti 1.2.16 → 1.3.9

data/lib/graphiti/scope.rb

@@ -3,10 +3,10 @@ module Graphiti
     attr_accessor :object, :unpaginated_object
     attr_reader :pagination
     def initialize(object, resource, query, opts = {})
-      @object    = object
-      @resource  = resource
-      @query     = query
-      @opts      = opts
+      @object = object
+      @resource = resource
+      @query = query
+      @opts = opts
 
       @object = @resource.around_scoping(@object, @query.hash) { |scope|
         apply_scoping(scope, opts)
@@ -45,9 +45,7 @@ module Graphiti
         resolve_sideload = -> {
           Graphiti.context = graphiti_context
           sideload.resolve(results, q, parent_resource)
-          if concurrent && defined?(ActiveRecord)
-            ActiveRecord::Base.clear_active_connections!
-          end
+          @resource.adapter.close if concurrent
         }
         if concurrent
           promises << Concurrent::Promise.execute(&resolve_sideload)
@@ -75,7 +73,7 @@ module Graphiti
         resource: @resource,
         params: @opts[:params],
         sideload: @opts[:sideload],
-        parent: @opts[:parent],
+        parent: @opts[:parent]
         # Set once data is resolved within block
         #   results: ...
       }
@@ -87,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/base.rb

@@ -25,9 +25,9 @@ module Graphiti
       # @param [Hash] opts configuration options used by subclasses
       def initialize(resource, query_hash, scope, opts = {})
         @query_hash = query_hash
-        @resource   = resource
-        @scope      = scope
-        @opts       = opts
+        @resource = resource
+        @scope = scope
+        @opts = opts
       end
 
       # Apply this scoping criteria.

data/lib/graphiti/scoping/filter.rb

@@ -3,6 +3,13 @@ module Graphiti
     include Scoping::Filterable
 
     def apply
+      unless @opts[:bypass_required_filters]
+        Graphiti::Scoping::FilterGroupValidator.new(
+          resource,
+          query_hash
+        ).raise_unless_filter_group_requirements_met!
+      end
+
       if missing_required_filters.any? && !@opts[:bypass_required_filters]
         raise Errors::RequiredFilter.new(resource, missing_required_filters)
       end
@@ -31,7 +38,7 @@ module Graphiti
 
     def filter_via_adapter(filter, operator, value)
       type_name = Types.name_for(filter.values.first[:type])
-      method    = :"filter_#{type_name}_#{operator}"
+      method = :"filter_#{type_name}_#{operator}"
       attribute = filter.keys.first
 
       if resource.adapter.respond_to?(method)
@@ -54,6 +61,8 @@ module Graphiti
           unless type[:canonical_name] == :hash || !value.is_a?(String)
             value = parse_string_value(filter.values[0], value)
           end
+
+          check_deny_empty_filters!(resource, filter, value)
           value = parse_string_null(filter.values[0], value)
           validate_singular(resource, filter, value)
           value = coerce_types(filter.values[0], param_name.to_sym, value)
@@ -82,11 +91,11 @@ module Graphiti
       type = Types[filter.values[0][:type]][:canonical_name]
       if param_value.is_a?(Hash) && type == :hash
         operators_keys = filter.values[0][:operators].keys
-        unless param_value.keys.all? {|k| operators_keys.include?(k)}
-          param_value = { eq: param_value }
+        unless param_value.keys.all? { |k| operators_keys.include?(k) }
+          param_value = {eq: param_value}
         end
       elsif !param_value.is_a?(Hash) || param_value.empty?
-        param_value = { eq: param_value }
+        param_value = {eq: param_value}
       end
 
       param_value.map do |operator, value|
@@ -162,14 +171,18 @@ module Graphiti
       type = Graphiti::Types[filter[:type]]
       array_or_string = [:string, :array].include?(type[:canonical_name])
       if (arr = value.scan(/\[.*?\]/)).present? && array_or_string
-        value = arr.map { |json|
-          begin
-            JSON.parse(json)
-          rescue
-            raise Errors::InvalidJSONArray.new(resource, value)
-          end
-        }
-        value = value[0] if value.length == 1
+        begin
+          value = arr.map { |json|
+            begin
+              JSON.parse(json)
+            rescue
+              raise Errors::InvalidJSONArray.new(resource, value)
+            end
+          }
+          value = value[0] if value.length == 1
+        rescue Errors::InvalidJSONArray => e
+          raise(e) if type[:canonical_name] == :array
+        end
       else
         value = parse_string_arrays(value, !!filter[:single])
       end
@@ -184,10 +197,10 @@ module Graphiti
       # remove the quote characters from the quoted strings
       quotes.each { |q| q.gsub!("{{", "").gsub!("}}", "") }
       # merge everything back together into an array
-      if singular_filter
-        value = Array(value) + quotes
+      value = if singular_filter
+        Array(value) + quotes
       else
-        value = Array(value.split(",")) + quotes
+        Array(value.split(",")) + quotes
       end
       # remove any blanks that are left
       value.reject! { |v| v.length.zero? }
@@ -200,5 +213,13 @@ module Graphiti
 
       value
     end
+
+    def check_deny_empty_filters!(resource, filter, value)
+      return unless filter.values[0][:deny_empty]
+
+      if value.nil? || value.empty? || value == "null"
+        raise Errors::InvalidFilterValue.new(resource, filter, "(empty)")
+      end
+    end
   end
 end

data/lib/graphiti/scoping/filter_group_validator.rb

@@ -0,0 +1,78 @@
+module Graphiti
+  class Scoping::FilterGroupValidator
+    VALID_REQUIRED_VALUES = %i[all any]
+
+    def self.raise_unless_filter_group_requirement_valid!(resource, requirement)
+      unless VALID_REQUIRED_VALUES.include?(requirement)
+        raise Errors::FilterGroupInvalidRequirement.new(
+          resource,
+          VALID_REQUIRED_VALUES
+        )
+      end
+
+      true
+    end
+
+    def initialize(resource, query_hash)
+      @resource = resource
+      @query_hash = query_hash
+    end
+
+    def raise_unless_filter_group_requirements_met!
+      return if grouped_filters.empty?
+
+      case filter_group_requirement
+      when :all
+        raise_unless_all_requirements_met!
+      when :any
+        raise_unless_any_requirements_met!
+      end
+
+      true
+    end
+
+    private
+
+    attr_reader :resource, :query_hash
+
+    def raise_unless_all_requirements_met!
+      met = filter_group_names.all? { |filter_name| filter_group_filter_param.key?(filter_name) }
+
+      unless met
+        raise Errors::FilterGroupMissingRequiredFilters.new(
+          resource,
+          filter_group_names,
+          filter_group_requirement
+        )
+      end
+    end
+
+    def raise_unless_any_requirements_met!
+      met = filter_group_names.any? { |filter_name| filter_group_filter_param.key?(filter_name) }
+
+      unless met
+        raise Errors::FilterGroupMissingRequiredFilters.new(
+          resource,
+          filter_group_names,
+          filter_group_requirement
+        )
+      end
+    end
+
+    def filter_group_names
+      grouped_filters.fetch(:names, [])
+    end
+
+    def filter_group_requirement
+      grouped_filters.fetch(:required, :invalid)
+    end
+
+    def grouped_filters
+      resource.grouped_filters
+    end
+
+    def filter_group_filter_param
+      query_hash.fetch(:filter, {})
+    end
+  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
@@ -33,24 +34,67 @@ module Graphiti
 
     # Apply default pagination proc via the Resource adapter
     def apply_standard_scope
-      resource.adapter.paginate(@scope, number, size)
+      meth = resource.adapter.method(:paginate)
+
+      if meth.arity == 4 # backwards-compat
+        resource.adapter.paginate(@scope, number, size, offset)
+      else
+        resource.adapter.paginate(@scope, number, size)
+      end
     end
 
     # Apply the custom pagination proc
     def apply_custom_scope
-      resource.instance_exec(@scope, number, size, resource.context, &custom_scope)
+      resource.instance_exec \
+        @scope,
+        number,
+        size,
+        resource.context,
+        offset,
+        &custom_scope
     end
 
     private
 
     def requested?
-      ![page_param[:size], page_param[:number]].all?(&:nil?)
+      !PARAMS.map { |p| page_param[p] }.all?(&:nil?)
     end
 
     def page_param
       @page_param ||= (query_hash[:page] || {})
     end
 
+    def offset
+      offset = nil
+
+      if (value = page_param[:offset])
+        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
       (page_param[:number] || 1).to_i
     end

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
 
@@ -78,7 +76,7 @@ module Graphiti
 
     def sort_hash(attr)
       value = attr[0] == "-" ? :desc : :asc
-      key   = attr.sub("-", "").to_sym
+      key = attr.sub("-", "").to_sym
 
       {key => value}
     end

data/lib/graphiti/serializer.rb

@@ -12,26 +12,62 @@ module Graphiti
     # go through type checking/coercion
     class_attribute :attributes_applied_via_resource
     class_attribute :extra_attributes_applied_via_resource
+    class_attribute :relationship_condition_blocks
     self.attributes_applied_via_resource = []
     self.extra_attributes_applied_via_resource = []
+    # See #requested_relationships
+    self.relationship_condition_blocks ||= {}
 
     def self.inherited(klass)
       super
       klass.class_eval do
         extend JSONAPI::Serializable::Resource::ConditionalFields
+
+        # See #requested_relationships
+        def self.relationship(name, options = {}, &block)
+          prev = Util::Hash.deep_dup(field_condition_blocks)
+          super
+          self.field_condition_blocks = prev
+          _register_condition(relationship_condition_blocks, name, options)
+        end
+
+        # NB - avoid clobbering includes when sparse fieldset
+        # https://github.com/jsonapi-rb/jsonapi-serializable/pull/102
+        #
+        # We also override this method to ensure attributes and relationships
+        # have separate condition blocks. This way an attribute and
+        # relationship can have the same name, and the attribute can be
+        # conditional without affecting the relationship.
+        def requested_relationships(fields)
+          @_relationships.select do |k, _|
+            _conditionally_included?(self.class.relationship_condition_blocks, k)
+          end
+        end
       end
     end
 
-    def as_jsonapi(*)
-      super.tap do |hash|
-        strip_relationships!(hash) if strip_relationships?
+    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
 
-    # Temporary fix until fixed upstream
-    # https://github.com/jsonapi-rb/jsonapi-serializable/pull/102
-    def requested_relationships(fields)
-      @_relationships
+    def as_jsonapi(kwargs = {})
+      super(**kwargs).tap do |hash|
+        strip_relationships!(hash) if strip_relationships?
+        add_links!(hash)
+      end
     end
 
     # Allow access to resource methods
@@ -49,6 +85,12 @@ module Graphiti
 
     private
 
+    def add_links!(hash)
+      return unless @resource.respond_to?(:links?)
+
+      hash[:links] = @resource.links(@object) if @resource.links?
+    end
+
     def strip_relationships!(hash)
       hash[:relationships]&.select! do |name, payload|
         payload.key?(:data)

data/lib/graphiti/sideload/belongs_to.rb

@@ -1,6 +1,6 @@
 class Graphiti::Sideload::BelongsTo < Graphiti::Sideload
   def initialize(name, opts)
-    opts = { always_include_resource_ids: false }.merge(opts)
+    opts = {always_include_resource_ids: false}.merge(opts)
     super(name, opts)
   end
 

data/lib/graphiti/sideload/has_many.rb

@@ -1,8 +1,18 @@
 class Graphiti::Sideload::HasMany < Graphiti::Sideload
+  def initialize(name, opts)
+    @inverse_filter = opts[:inverse_filter]
+
+    super(name, opts)
+  end
+
   def type
     :has_many
   end
 
+  def inverse_filter
+    @inverse_filter || foreign_key
+  end
+
   def load_params(parents, query)
     query.hash.tap do |hash|
       hash[:filter] ||= {}
@@ -11,11 +21,19 @@ class Graphiti::Sideload::HasMany < Graphiti::Sideload
   end
 
   def base_filter(parents)
-    {foreign_key => ids_for_parents(parents).join(",")}
+    {foreign_key => parent_filter(parents)}
+  end
+
+  def link_filter(parents)
+    {inverse_filter => parent_filter(parents)}
   end
 
   private
 
+  def parent_filter(parents)
+    ids_for_parents(parents).join(",")
+  end
+
   def child_map(children)
     children.group_by(&foreign_key)
   end

data/lib/graphiti/sideload/many_to_many.rb

@@ -11,8 +11,12 @@ class Graphiti::Sideload::ManyToMany < Graphiti::Sideload::HasMany
     foreign_key.values.first
   end
 
+  def inverse_filter
+    @inverse_filter || true_foreign_key
+  end
+
   def base_filter(parents)
-    {true_foreign_key => ids_for_parents(parents).join(",")}
+    {true_foreign_key => parent_filter(parents)}
   end
 
   def infer_foreign_key
@@ -32,9 +36,12 @@ class Graphiti::Sideload::ManyToMany < Graphiti::Sideload::HasMany
     self_ref = self
     fk_type = parent_resource_class.attributes[:id][:type]
     fk_type = :hash if polymorphic?
-    resource_class.filter true_foreign_key, fk_type do
-      eq do |scope, value|
-        self_ref.belongs_to_many_filter(scope, value)
+    # Do not recreate if filter already exists
+    unless resource_class.config[:filters].has_key?(inverse_filter.to_sym)
+      resource_class.filter inverse_filter, fk_type do
+        eq do |scope, value|
+          self_ref.belongs_to_many_filter(scope, value)
+        end
       end
     end
   end

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/sideload.rb

@@ -18,31 +18,31 @@ module Graphiti
       :link_proc
 
     def initialize(name, opts)
-      @name                          = name
+      @name = name
       validate_options!(opts)
-      @parent_resource_class         = opts[:parent_resource]
-      @resource_class                = opts[:resource]
-      @primary_key                   = opts[:primary_key]
-      @foreign_key                   = opts[:foreign_key]
-      @type                          = opts[:type]
-      @base_scope                    = opts[:base_scope]
-      @readable                      = evaluate_flag(opts[:readable])
-      @writable                      = evaluate_flag(opts[:writable])
-      @as                            = opts[:as]
-      @link                          = opts[:link]
-      @single                        = opts[:single]
-      @remote                        = opts[:remote]
+      @parent_resource_class = opts[:parent_resource]
+      @resource_class = opts[:resource]
+      @primary_key = opts[:primary_key]
+      @foreign_key = opts[:foreign_key]
+      @type = opts[:type]
+      @base_scope = opts[:base_scope]
+      @readable = opts[:readable]
+      @writable = opts[:writable]
+      @as = opts[:as]
+      @link = opts[:link]
+      @single = opts[:single]
+      @remote = opts[:remote]
       apply_belongs_to_many_filter if type == :many_to_many
 
-      @description                   = opts[:description]
+      @description = opts[:description]
 
       # polymorphic has_many
-      @polymorphic_as                = opts[:polymorphic_as]
+      @polymorphic_as = opts[:polymorphic_as]
       # polymorphic_belongs_to-specific
-      @group_name                    = opts[:group_name]
-      @polymorphic_child             = opts[:polymorphic_child]
-      @parent                        = opts[:parent]
-      @always_include_resource_ids   = opts[:always_include_resource_ids]
+      @group_name = opts[:group_name]
+      @polymorphic_child = opts[:polymorphic_child]
+      @parent = opts[:parent]
+      @always_include_resource_ids = opts[:always_include_resource_ids]
 
       if polymorphic_child?
         parent.resource.polymorphic << resource_class
@@ -132,6 +132,23 @@ module Graphiti
       end
     end
 
+    def link_filter(parents)
+      base_filter(parents)
+    end
+
+    def link_extra_fields
+      return unless context&.respond_to?(:params)
+
+      extra_fields_name = [association_name, resource.type].find { |param|
+        context.params.dig(:extra_fields, param)
+      }
+
+      if extra_fields_name
+        extra_fields = context.params.dig(:extra_fields, extra_fields_name)
+        {resource.type => extra_fields}
+      end
+    end
+
     # The parent resource is a remote,
     # AND the sideload is a remote to the same endpoint
     def shared_remote?
@@ -197,7 +214,7 @@ module Graphiti
 
       with_error_handling Errors::SideloadParamsError do
         params = load_params(parents, query)
-        params_proc&.call(params, parents)
+        params_proc&.call(params, parents, context)
         return [] if blank_query?(params)
         opts = load_options(parents, query)
         opts[:sideload] = self
@@ -205,7 +222,9 @@ module Graphiti
       end
 
       with_error_handling(Errors::SideloadQueryBuildingError) do
-        proxy = resource.class._all(params, opts, base_scope)
+        scope = base_scope
+        scope[:foreign_key] = foreign_key if remote?
+        proxy = resource.class._all(params, opts, scope)
         pre_load_proc&.call(proxy, parents)
       end
 
@@ -422,17 +441,22 @@ module Graphiti
       Util::Class.namespace_for(klass)
     end
 
+    # TODO: call this at runtime to support procs
     def evaluate_flag(flag)
       return false if flag.blank?
 
       case flag.class.name
-      when "Symbol","String"
+      when "Symbol", "String"
         resource.send(flag)
       when "Proc"
-        self.resource.instance_exec(&flag)
+        resource.instance_exec(&flag)
       else
         !!flag
       end
     end
+
+    def context
+      Graphiti.context[:object]
+    end
   end
 end

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