graphiti 1.2.31 → 1.3.4

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

@@ -12,14 +12,55 @@ 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 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 = {})
@@ -29,12 +70,6 @@ module Graphiti
       end
     end
 
-    # Temporary fix until fixed upstream
-    # https://github.com/jsonapi-rb/jsonapi-serializable/pull/102
-    def requested_relationships(fields)
-      @_relationships
-    end
-
     # Allow access to resource methods
     def method_missing(id, *args, &blk)
       if @resource.respond_to?(id, true)

data/lib/graphiti/sideload.rb

@@ -136,6 +136,19 @@ module Graphiti
       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?
@@ -209,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
 

data/lib/graphiti/util/class.rb

@@ -20,6 +20,12 @@ module Graphiti
         split = namespace.split("::")
         split[0, split.length - 1].join("::")
       end
+
+      def self.graphql_type_name(name)
+        name.gsub("Resource", "")
+          .gsub("::", "") # remove modules
+          .gsub(".", "__") # remove remote resource .
+      end
     end
   end
 end

data/lib/graphiti/util/link.rb

@@ -63,6 +63,10 @@ module Graphiti
             params[:filter] = @sideload.link_filter([@model])
           end
 
+          if (extra_fields = @sideload.link_extra_fields)
+            params[:extra_fields] ||= extra_fields
+          end
+
           @sideload.params_proc&.call(params, [@model], context)
         end
       end

data/lib/graphiti/util/remote_params.rb

@@ -2,13 +2,14 @@
 module Graphiti
   module Util
     class RemoteParams
-      def self.generate(resource, query)
-        new(resource, query).generate
+      def self.generate(resource, query, foreign_key)
+        new(resource, query, foreign_key).generate
       end
 
-      def initialize(resource, query)
+      def initialize(resource, query, foreign_key)
         @resource = resource
         @query = query
+        @foreign_key = foreign_key
         @sorts = []
         @filters = {}
         @fields = {}
@@ -97,7 +98,11 @@ module Graphiti
         return unless fields
 
         fields.each_pair do |type, attrs|
-          @fields[type] = attrs.join(",")
+          all_attrs = attrs
+          if @foreign_key
+            all_attrs |= [@foreign_key]
+          end
+          @fields[type] = all_attrs.join(",")
         end
       end
 

data/lib/graphiti/util/remote_serializer.rb

@@ -44,6 +44,7 @@ module Graphiti
           model.delete_field(:_relationships)
           # If this isn't set, Array(resources) will return []
           # This is important, because jsonapi-serializable makes this call
+          # To see the test failure, remote resource position > department
           model.instance_variable_set(:@__graphiti_resource, 1)
           model.instance_variable_set(:@__graphiti_serializer, serializer)
         end

data/lib/graphiti/util/serializer_attributes.rb

@@ -12,26 +12,48 @@ module Graphiti
       def apply
         return unless readable?
 
+        remove_guard if previously_guarded?
+
         if @name == :id
           @serializer.id(&proc)
-        elsif @attr[:proc]
-          @serializer.send(_method, @name, serializer_options, &proc)
-        elsif @serializer.attribute_blocks[@name].nil?
+        elsif @attr[:proc] ||
+            !previously_applied? ||
+            previously_applied_via_resource?
           @serializer.send(_method, @name, serializer_options, &proc)
-        else
-          unless @serializer.send(applied_method).include?(@name)
-            inner = @serializer.attribute_blocks.delete(@name)
-            wrapped = wrap_proc(inner)
-            @serializer.send(_method, @name, serializer_options, &wrapped)
-          end
+        else # Previously applied via explicit serializer, so wrap it
+          inner = @serializer.attribute_blocks.delete(@name)
+          wrapped = wrap_proc(inner)
+          @serializer.send(_method, @name, serializer_options, &wrapped)
         end
 
         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
 
+      def previously_applied?
+        @serializer.attribute_blocks[@name].present?
+      end
+
+      def previously_applied_via_resource?
+        @serializer.send(applied_method).include?(@name)
+      end
+
+      def previously_guarded?
+        @serializer.field_condition_blocks[@name]
+      end
+
+      def remove_guard
+        @serializer.field_condition_blocks.delete(@name)
+      end
+
       def applied_method
         if extra?
           :extra_attributes_applied_via_resource
@@ -56,16 +78,21 @@ module Graphiti
         method_name = @attr[:readable]
         instance = @resource.new
         attribute = @name.to_s
+        resource_class = @resource
 
         -> {
           method = instance.method(method_name)
-          if method.arity.zero?
+          result = if method.arity.zero?
             instance.instance_eval(&method_name)
           elsif method.arity == 1
             instance.instance_exec(@object, &method)
           else
             instance.instance_exec(@object, attribute, &method)
           end
+          if Graphiti.context[:graphql] && !result
+            raise ::Graphiti::Errors::UnreadableAttribute.new(resource_class, attribute)
+          end
+          result
         }
       end
 

data/lib/graphiti/version.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "1.2.31"
+  VERSION = "1.3.4"
 end

data/lib/graphiti.rb

@@ -6,6 +6,7 @@ require "active_support/core_ext/class/attribute"
 require "active_support/core_ext/hash/conversions" # to_xml
 require "active_support/concern"
 require "active_support/time"
+require "active_support/deprecation"
 
 require "dry-types"
 require "graphiti_errors"
@@ -141,6 +142,7 @@ require "graphiti/scoping/sort"
 require "graphiti/scoping/paginate"
 require "graphiti/scoping/extra_attributes"
 require "graphiti/scoping/filterable"
+require "graphiti/scoping/filter_group_validator"
 require "graphiti/scoping/default_filter"
 require "graphiti/scoping/filter"
 require "graphiti/stats/dsl"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 1.2.31
+  version: 1.3.4
 platform: ruby
 authors:
 - Lee Richmond
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-02 00:00:00.000000000 Z
+date: 2021-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-serializable
@@ -308,6 +308,7 @@ files:
 - lib/graphiti/scoping/default_filter.rb
 - lib/graphiti/scoping/extra_attributes.rb
 - lib/graphiti/scoping/filter.rb
+- lib/graphiti/scoping/filter_group_validator.rb
 - lib/graphiti/scoping/filterable.rb
 - lib/graphiti/scoping/paginate.rb
 - lib/graphiti/scoping/sort.rb
@@ -360,7 +361,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: Easily build jsonapi.org-compatible APIs