graphiti 1.2.33 → 1.2.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fd3e0460824b4c80d8bf5e1cb798b94a297bdb39ab077cb655b9fe085779bd2
-  data.tar.gz: 3ae7e9ef0209b9bd0c823cd323bc3f066f2116a807ad66f714d3c63205351649
+  metadata.gz: c269e7e8afb7836e7d20aa4d8f837f10ef8576356da1d8c76b93b40bc630a97c
+  data.tar.gz: 29ffb9ec585198d92ab8cb75f23562f96ad8f82115301844b389374cbc94cd67
 SHA512:
-  metadata.gz: 8e294afd7a47b32fbc4aa0ba695aafbeb43f42bf4c32d6f05eb2a182bca4e6b0ab0bdd68ad8a54dda8b7cee24636b0097b52629895adb758c3d2b148e3dda7c7
-  data.tar.gz: 8454b4433f15af9464d9b708dad9cb16dff9fb368085b1297aa733f5a8dcb56a0621f4cfdbb63bfe06931d24bd17378c42655059b68a763025a33a5903605c34
+  metadata.gz: a5cfe7c03f2a66e3f874902030e56aed8561ed81b4dd5bca849bee82b902d908f4faa32131842220fa1b010b9c2b2276b9158a852e2cf58ddf6f4b5118769dd1
+  data.tar.gz: 39b5ffbfa860fcdf1601c2f718c75d401bb2851a1c1c496f5930a81d64329845bba0d4fa7312128d8da25bfe07624fc2be777ccaf768257ae4d6d0291d6796d8

data/CHANGELOG.md

@@ -1,6 +1,7 @@
 ## Unreleased
 
 Features:
+- [329](https://github.com/graphiti-api/graphiti/pull/329) Propagate `extra_fields` to related resource links.
 - [242](https://github.com/graphiti-api/graphiti/pull/242) Bump `jsonapi-renderer` to `~0.2.2` now that (https://github.com/jsonapi-rb/jsonapi-renderer/pull/36) is fixed.
 - [158](https://github.com/graphiti-api/graphiti/pull/158) Filters options `allow_nil: true`
   Option can be set at the resource level `Resource.filters_accept_nil_by_default = true`. 

data/lib/graphiti.rb

@@ -142,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"

data/lib/graphiti/errors.rb

@@ -14,13 +14,12 @@ module Graphiti
     end
 
     class NullRelation
-      extend ActiveModel::Naming
       attr_accessor :id, :errors, :pointer
 
       def initialize(id, pointer)
         @id = id
         @pointer = pointer
-        @errors = ActiveModel::Errors.new(self)
+        @errors = Graphiti::Util::SimpleErrors.new(self)
       end
 
       def self.human_attribute_name(attr, options = {})
@@ -817,5 +816,34 @@ module Graphiti
 
     class ConflictRequest < InvalidRequest
     end
+
+    class FilterGroupInvalidRequirement < Base
+      def initialize(resource, valid_required_values)
+        @resource = resource
+        @valid_required_values = valid_required_values
+      end
+
+      def message
+        <<-MSG.gsub(/\s+/, " ").strip
+          The filter group required: value on resource #{@resource.class} must be one of the following:
+          #{@valid_required_values.join(", ")}
+        MSG
+      end
+    end
+
+    class FilterGroupMissingRequiredFilters < Base
+      def initialize(resource, filter_names, required)
+        @resource = resource
+        @filter_names = filter_names
+        @required_label = required == :all ? "All" : "One"
+      end
+
+      def message
+        <<-MSG.gsub(/\s+/, " ").strip
+          #{@required_label} of the following filters must be provided on resource #{@resource.type}:
+          #{@filter_names.join(", ")}
+        MSG
+      end
+    end
   end
 end

data/lib/graphiti/extensions/extra_attribute.rb

@@ -46,9 +46,9 @@ module Graphiti
               next false unless instance_exec(&options[:if])
             end
 
-            @extra_fields &&
-              @extra_fields[@_type] &&
-              @extra_fields[@_type].include?(name)
+            next false unless @extra_fields
+
+            @extra_fields[@_type]&.include?(name) || @extra_fields[@resource&.type]&.include?(name)
           }
 
           attribute name, if: allow_field, &blk

data/lib/graphiti/hash_renderer.rb

@@ -74,19 +74,22 @@ module Graphiti
           name_chain << k unless name_chain.last == k
 
           unless remote_resource? && serializers.nil?
-            attrs[name.to_sym] = if serializers.is_a?(Array)
-              serializers.map do |rr|
+            payload = if serializers.is_a?(Array)
+              data = serializers.map { |rr|
                 rr.to_hash(fields: fields, include: nested_include, graphql: graphql, name_chain: name_chain)
-              end
+              }
+              graphql ? {nodes: data} : data
             elsif serializers.nil?
               if @resource.class.respond_to?(:sideload)
                 if @resource.class.sideload(k).type.to_s.include?("_many")
-                  []
+                  graphql ? {nodes: []} : []
                 end
               end
             else
               serializers.to_hash(fields: fields, include: nested_include, graphql: graphql, name_chain: name_chain)
             end
+
+            attrs[name.to_sym] = payload
           end
         end
 
@@ -133,29 +136,58 @@ module Graphiti
       serializers = options[:data]
       opts = options.slice(:fields, :include)
       opts[:graphql] = @graphql
-      to_hash(serializers, opts).tap do |hash|
-        hash.merge!(options.slice(:meta)) unless options[:meta].empty?
-      end
+      top_level_key = get_top_level_key(@resource, serializers.is_a?(Array))
+
+      hash = {top_level_key => {}}
+      nodes = get_nodes(serializers, opts)
+      add_nodes(hash, top_level_key, options, nodes, @graphql)
+      add_stats(hash, top_level_key, options, @graphql)
+      hash
     end
 
     private
 
-    def to_hash(serializers, opts)
-      {}.tap do |hash|
-        top_level_key = :data
-        if @graphql
-          top_level_key = @resource.graphql_entrypoint
-          unless serializers.is_a?(Array)
-            top_level_key = top_level_key.to_s.singularize.to_sym
-          end
+    def get_top_level_key(resource, is_many)
+      key = :data
+
+      if @graphql
+        key = @resource.graphql_entrypoint
+        key = key.to_s.singularize.to_sym unless is_many
+      end
+
+      key
+    end
+
+    def get_nodes(serializers, opts)
+      if serializers.is_a?(Array)
+        serializers.map do |s|
+          s.to_hash(**opts)
         end
+      else
+        serializers.to_hash(**opts)
+      end
+    end
+
+    def add_nodes(hash, top_level_key, opts, nodes, graphql)
+      payload = nodes
+      if graphql && nodes.is_a?(Array)
+        payload = {nodes: nodes}
+      end
 
-        hash[top_level_key] = if serializers.is_a?(Array)
-          serializers.map do |s|
-            s.to_hash(**opts)
+      # Don't render nodes if we only requested stats
+      unless graphql && opts[:fields].values == [[:stats]]
+        hash[top_level_key] = payload
+      end
+    end
+
+    def add_stats(hash, top_level_key, options, graphql)
+      if options[:meta] && !options[:meta].empty?
+        if @graphql
+          if (stats = options[:meta][:stats])
+            hash[top_level_key][:stats] = stats
           end
         else
-          serializers.to_hash(**opts)
+          hash.merge!(options.slice(:meta))
         end
       end
     end

data/lib/graphiti/request_validators/update_validator.rb

@@ -26,17 +26,17 @@ module Graphiti
           [:data, :type],
           [:data, :id]
         ].each do |required_attr|
-          attribute_mismatch(required_attr) unless @raw_params.dig(*required_attr)
+          attribute_mismatch(required_attr) unless @params.dig(*required_attr)
         end
         errors.blank?
       end
 
       def payload_matches_endpoint?
-        unless @raw_params.dig(:data, :id) == @raw_params.dig(:filter, :id)
+        unless @params.dig(:data, :id) == @params.dig(:filter, :id)
           attribute_mismatch([:data, :id])
         end
 
-        meta_type = @raw_params.dig(:data, :type)
+        meta_type = @params.dig(:data, :type)
 
         # NOTE: calling #to_s and comparing 2 strings is slower than
         # calling #to_sym and comparing 2 symbols. But pre ruby-2.2

data/lib/graphiti/request_validators/validator.rb

@@ -5,21 +5,31 @@ module Graphiti
 
       def initialize(root_resource, raw_params, action)
         @root_resource = root_resource
-        @raw_params = raw_params
+        @params = normalized_params(raw_params)
         @errors = Graphiti::Util::SimpleErrors.new(raw_params)
         @action = action
       end
 
       def validate
+        # Right now, all requests - even reads - go through the validator
+        # In the future these should have their own validation logic, but
+        # for now we can just bypass
+        return true unless @params.has_key?(:data)
+
         resource = @root_resource
-        if (meta_type = deserialized_payload.meta[:type].try(:to_sym))
-          if @root_resource.type != meta_type && @root_resource.polymorphic?
-            resource = @root_resource.class.resource_for_type(meta_type).new
+
+        if @params[:data].has_key?(:type)
+          if (meta_type = deserialized_payload.meta[:type].try(:to_sym))
+            if @root_resource.type != meta_type && @root_resource.polymorphic?
+              resource = @root_resource.class.resource_for_type(meta_type).new
+            end
           end
-        end
 
-        typecast_attributes(resource, deserialized_payload.attributes, deserialized_payload.meta[:payload_path])
-        process_relationships(resource, deserialized_payload.relationships, deserialized_payload.meta[:payload_path])
+          typecast_attributes(resource, deserialized_payload.attributes, deserialized_payload.meta[:payload_path])
+          process_relationships(resource, deserialized_payload.relationships, deserialized_payload.meta[:payload_path])
+        else
+          errors.add(:"data.type", :missing)
+        end
 
         errors.blank?
       end
@@ -33,14 +43,7 @@ module Graphiti
       end
 
       def deserialized_payload
-        @deserialized_payload ||= begin
-                                    payload = normalized_params
-                                    if payload[:data] && payload[:data][:type]
-                                      Graphiti::Deserializer.new(payload)
-                                    else
-                                      Graphiti::Deserializer.new({})
-                                    end
-                                  end
+        @deserialized_payload ||= Graphiti::Deserializer.new(@params)
       end
 
       private
@@ -86,8 +89,8 @@ module Graphiti
         end
       end
 
-      def normalized_params
-        normalized = @raw_params
+      def normalized_params(raw_params)
+        normalized = raw_params
         if normalized.respond_to?(:to_unsafe_h)
           normalized = normalized.to_unsafe_h.deep_symbolize_keys
         end

data/lib/graphiti/resource/configuration.rb

@@ -199,6 +199,7 @@ module Graphiti
           @config ||=
             {
               filters: {},
+              grouped_filters: {},
               default_filters: {},
               stats: {},
               sort_all: nil,
@@ -235,6 +236,10 @@ module Graphiti
           config[:filters]
         end
 
+        def grouped_filters
+          config[:grouped_filters]
+        end
+
         def sorts
           config[:sorts]
         end
@@ -273,6 +278,10 @@ module Graphiti
         self.class.filters
       end
 
+      def grouped_filters
+        self.class.grouped_filters
+      end
+
       def sort_all
         self.class.sort_all
       end

data/lib/graphiti/resource/dsl.rb

@@ -44,6 +44,17 @@ module Graphiti
           end
         end
 
+        def filter_group(filter_names, *args)
+          opts = args.extract_options!
+
+          Scoping::FilterGroupValidator.raise_unless_filter_group_requirement_valid!(self, opts[:required])
+
+          config[:grouped_filters] = {
+            names: filter_names,
+            required: opts[:required]
+          }
+        end
+
         def sort_all(&blk)
           if block_given?
             config[:_sort_all] = blk

data/lib/graphiti/schema.rb

@@ -96,9 +96,14 @@ module Graphiti
           extra_attributes: extra_attributes(r),
           sorts: sorts(r),
           filters: filters(r),
-          relationships: relationships(r)
+          relationships: relationships(r),
+          stats: stats(r)
         }
 
+        if r.grouped_filters.any?
+          config[:filter_group] = r.grouped_filters
+        end
+
         if r.default_sort
           default_sort = r.default_sort.map { |s|
             {s.keys.first.to_s => s.values.first.to_s}
@@ -165,6 +170,14 @@ module Graphiti
       end
     end
 
+    def stats(resource)
+      {}.tap do |stats|
+        resource.stats.each_pair do |name, config|
+          stats[name] = config.calculations.keys
+        end
+      end
+    end
+
     def sorts(resource)
       {}.tap do |s|
         resource.sorts.each_pair do |name, sort|
@@ -212,6 +225,10 @@ module Graphiti
       end
     end
 
+    def filter_group(resource)
+      resource.config[:grouped_filters]
+    end
+
     def relationships(resource)
       {}.tap do |r|
         resource.sideloads.each_pair do |name, config|

data/lib/graphiti/schema_diff.rb

@@ -1,8 +1,8 @@
 module Graphiti
   class SchemaDiff
     def initialize(old, new)
-      @old = old.deep_symbolize_keys
-      @new = new.deep_symbolize_keys
+      @old = JSON.parse(old.to_json).deep_symbolize_keys
+      @new = JSON.parse(new.to_json).deep_symbolize_keys
       @errors = []
     end
 
@@ -30,6 +30,8 @@ module Graphiti
           compare_extra_attributes(r, new_resource)
           compare_sorts(r, new_resource)
           compare_filters(r, new_resource)
+          compare_filter_group(r, new_resource)
+          compare_stats(r, new_resource)
           compare_relationships(r, new_resource)
         end
       end
@@ -133,12 +135,12 @@ module Graphiti
         end
 
         if new_sort[:only] && !old_sort[:only]
-          @errors << "#{old_resource[:name]}: sort #{name.inspect} now limited to only #{new_sort[:only].inspect}."
+          @errors << "#{old_resource[:name]}: sort #{name.inspect} now limited to only #{new_sort[:only].to_sym.inspect}."
         end
 
         if new_sort[:only] && old_sort[:only]
           if new_sort[:only] != old_sort[:only]
-            @errors << "#{old_resource[:name]}: sort #{name.inspect} was limited to only #{old_sort[:only].inspect}, now limited to only #{new_sort[:only].inspect}."
+            @errors << "#{old_resource[:name]}: sort #{name.inspect} was limited to only #{old_sort[:only].to_sym.inspect}, now limited to only #{new_sort[:only].to_sym.inspect}."
           end
         end
       end
@@ -204,6 +206,44 @@ module Graphiti
       end
     end
 
+    def compare_filter_group(old_resource, new_resource)
+      if new_resource[:filter_group]
+        if old_resource[:filter_group]
+          new_names = new_resource[:filter_group][:names]
+          old_names = old_resource[:filter_group][:names]
+          diff = new_names - old_names
+          if !diff.empty? && new_resource[:filter_group][:required] == "all"
+            @errors << "#{old_resource[:name]}: all required filter group #{old_names.map(&:to_sym).inspect} added #{"member".pluralize(diff.length)} #{diff.map(&:to_sym).inspect}."
+          end
+
+          old_required = old_resource[:filter_group][:required]
+          new_required = new_resource[:filter_group][:required]
+          if old_required == "any" && new_required == "all"
+            @errors << "#{old_resource[:name]}: filter group #{old_names.map(&:to_sym).inspect} moved from required: :any to required: :all"
+          end
+        else
+          @errors << "#{old_resource[:name]}: filter group #{new_resource[:filter_group][:names].map(&:to_sym).inspect} was added."
+        end
+      end
+    end
+
+    def compare_stats(old_resource, new_resource)
+      return unless old_resource.key?(:stats)
+
+      old_resource[:stats].each_pair do |name, old_calculations|
+        new_calculations = new_resource[:stats][name]
+        if new_calculations
+          old_calculations.each do |calc|
+            unless new_calculations.include?(calc)
+              @errors << "#{old_resource[:name]}: calculation #{calc.to_sym.inspect} was removed from stat #{name.inspect}."
+            end
+          end
+        else
+          @errors << "#{old_resource[:name]}: stat #{name.inspect} was removed."
+        end
+      end
+    end
+
     def compare_endpoints
       @old[:endpoints].each_pair do |path, old_endpoint|
         unless (new_endpoint = @new[:endpoints][path])

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

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

@@ -136,6 +136,14 @@ module Graphiti
       base_filter(parents)
     end
 
+    def link_extra_fields
+      extra_fields_name = [association_name, resource.type].find { |param|
+        context.params.dig(:extra_fields, param)
+      }
+
+      {resource.type => context.params.dig(:extra_fields, extra_fields_name)} if extra_fields_name
+    end
+
     # The parent resource is a remote,
     # AND the sideload is a remote to the same endpoint
     def shared_remote?

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

@@ -16,13 +16,11 @@ module Graphiti
 
         if @name == :id
           @serializer.id(&proc)
-        elsif @attr[:proc]
+        elsif @attr[:proc] ||
+            !previously_applied? ||
+            previously_applied_via_resource?
           @serializer.send(_method, @name, serializer_options, &proc)
-        elsif @serializer.attribute_blocks[@name].nil?
-          @serializer.send(_method, @name, serializer_options, &proc)
-        elsif @serializer.send(applied_method).include?(@name)
-          @serializer.field_condition_blocks[@name] = guard if guard?
-        else
+        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)
@@ -34,6 +32,14 @@ module Graphiti
 
       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

data/lib/graphiti/version.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "1.2.33"
+  VERSION = "1.2.38"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 1.2.33
+  version: 1.2.38
 platform: ruby
 authors:
 - Lee Richmond
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-03-07 00:00:00.000000000 Z
+date: 2021-03-21 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