graphiti 1.2.34 → 1.2.39

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c877600c2b854433fd506185d43e64fce4e9f6c3a7cd37846fe60f724acd8f4
-  data.tar.gz: d1e30c54a384eda5a2b2f5224da346808c47a54aadf57610b1ccd7339d780234
+  metadata.gz: 6d2917a607d95ef6d4701b8960ed183fd39923662b034d74fda9f8080f65d534
+  data.tar.gz: 7fc8ec33363e0112c541d05c676c7315b1934876f15875ac0b153bf2fc6cebdd
 SHA512:
-  metadata.gz: 68b7f4d1d96c67d6d28976ed9ba8071e5d8376835cfbc61a2744e9792467e93dee4b4338fbeb4d7d3492f8a03aa935657726c0b66d0af69f4d061b5cdc29f1b7
-  data.tar.gz: 62a8b811497bfc1ffc06e4bb85f86ac573be0f7eb7b0a41cf915f6c0ee9fdf85460612c17708956c89472a6b7dad0d43c0087212db2779e0320211d9f99a93c9
+  metadata.gz: 6f9867cbf49483cb09a887db26af222e2d74962c07aaf6ece7552a73cf74b625ca49e19ed730c1f383f7706ae10546551d54792b2b09832709aa14829ddd8180
+  data.tar.gz: 746d7900a12437a7a610dc8d4e8737ada319867578349898cc95067d7295c1b04b659dec00e33aec0a9977c33ecafd0a58f9f07da61ec04def6ad8131656351f

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, @action, 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
@@ -62,15 +65,20 @@ module Graphiti
             next
           end
 
-          typecast_attributes(x[:resource], x[:attributes], x[:meta][:payload_path])
-          process_relationships(x[:resource], x[:relationships], x[:meta][:payload_path])
+          resource = x[:resource]
+          attributes = x[:attributes]
+          relationships = x[:relationships]
+          payload_path = x[:meta][:payload_path]
+          action = x[:meta][:method]
+          typecast_attributes(resource, attributes, action, payload_path)
+          process_relationships(resource, relationships, payload_path)
         end
       end
 
-      def typecast_attributes(resource, attributes, payload_path)
+      def typecast_attributes(resource, attributes, action, payload_path)
         attributes.each_pair do |key, value|
           # Only validate id if create action, otherwise it's only used for lookup
-          next if @action != :create &&
+          next if action != :create &&
             key == :id &&
             resource.class.config[:attributes][:id][:writable] == false
 
@@ -86,8 +94,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/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,10 +3,12 @@ module Graphiti
     include Scoping::Filterable
 
     def apply
-      Graphiti::Scoping::FilterGroupValidator.new(
-        resource,
-        query_hash
-      ).raise_unless_filter_group_requirements_met!
+      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)

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.34"
+  VERSION = "1.2.39"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 1.2.34
+  version: 1.2.39
 platform: ruby
 authors:
 - Lee Richmond
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-03-16 00:00:00.000000000 Z
+date: 2021-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-serializable
@@ -361,7 +361,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.6
 signing_key:
 specification_version: 4
 summary: Easily build jsonapi.org-compatible APIs