graphiti 1.2.35 → 1.2.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5aaea1da30c8eb6b86abc1be0df8fba47d2df8f55be42f6141f78976a2c02dea
-  data.tar.gz: c4611d1226bc10b04a755e29943bc131831cb9df23cb55480ab3daa3cfa8d4b5
+  metadata.gz: d10b110934848ed53d75bb0b8595f73c50524833818d39dc53f3859c393d342b
+  data.tar.gz: a28ab64e8453486628ee93d131914479c24d60ade77e8dd201030bbe68dd055c
 SHA512:
-  metadata.gz: 20c0ca9615484a566e528c5851702dfff7436c37e3ccf7774ef37611699397870bb74be19f633b1dfc9eca9c315642a29777412c66823550290bca8406e6a254
-  data.tar.gz: 1edb1ae4364f3b348fa74dffc6c8a794b0e54d39289144614e0c9e605e0dc3df6f850ea72b7117f99a72725ffc9cf536cda93a9694ee3a39a7cc21748405973b
+  metadata.gz: 1d1d78896c8079cfbc4e74f3f6b754047a5c597adfe87023340adae7c56029ef60873c5cfe91fd099d7aac7965db7048dfb45e10efa8d29a39e4cdbfc19d99e3
+  data.tar.gz: f563f24c252c72e49a8bc8ba52ac8a6c5ab814d7699817fce981adee68dc74edc6e3dc82f2a5fdc5986e1b07411fbad776df5bba7099baeae930b305a03e0b92

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

@@ -25,7 +25,7 @@ module Graphiti
             end
           end
 
-          typecast_attributes(resource, deserialized_payload.attributes, 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)
@@ -65,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
 

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

@@ -137,11 +137,16 @@ module Graphiti
     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)
       }
 
-      {resource.type => context.params.dig(:extra_fields, extra_fields_name)} if extra_fields_name
+      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,

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.35"
+  VERSION = "1.2.40"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 1.2.35
+  version: 1.2.40
 platform: ruby
 authors:
 - Lee Richmond
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-03-18 00:00:00.000000000 Z
+date: 2021-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-serializable