Accommodate statistics in hash renderer

* Add stats when requested
* Nest arrays within "nodes" key for GQL, so stats can be a sibling
* Don't render "nodes" when *only* stats requested & GQL
* Add stats to the schema/diffing

As with all hash rendering code, it's not lovely but gets the job done.
Did some benchmarking and if anything should render flat JSON very
slightly faster; JSON:API performance was equivalent.

Author: Lee Richmond

lib/graphiti/hash_renderer.rb

@@ -74,19 +74,22 @@ def to_hash(fields: nil, include: {}, name_chain: [], graphql: false)
           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 @@ def render(options)
       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

lib/graphiti/schema.rb

@@ -96,7 +96,8 @@ def generate_resources
           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?
@@ -169,6 +170,14 @@ def flag(value)
       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|

lib/graphiti/schema_diff.rb

@@ -31,6 +31,7 @@ def compare_resources
           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
@@ -226,6 +227,21 @@ def compare_filter_group(old_resource, new_resource)
       end
     end
 
+    def compare_stats(old_resource, new_resource)
+      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.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])

spec/rendering_spec.rb

@@ -486,9 +486,9 @@ def resolve(scope)
         end
 
         it "is not returned" do
-          expect(json[:employees][0]).to eq({
+          expect(json[:employees][:nodes][0]).to eq({
             firstName: "John",
-            positions: [{title: "title1"}]
+            positions: {nodes: [{title: "title1"}]}
           })
         end
       end
@@ -500,10 +500,10 @@ def resolve(scope)
         end
 
         it "is returned" do
-          expect(json[:employees][0]).to eq({
+          expect(json[:employees][:nodes][0]).to eq({
             id: employee1.id.to_s,
             firstName: "John",
-            positions: [{id: position1.id.to_s, title: "title1"}]
+            positions: {nodes: [{id: position1.id.to_s, title: "title1"}]}
           })
         end
       end
@@ -515,9 +515,9 @@ def resolve(scope)
         end
 
         it "is not returned" do
-          expect(json[:employees][0]).to eq({
+          expect(json[:employees][:nodes][0]).to eq({
             firstName: "John",
-            positions: [{title: "title1"}]
+            positions: {nodes: [{title: "title1"}]}
           })
         end
       end
@@ -529,10 +529,10 @@ def resolve(scope)
         end
 
         it "is returned" do
-          expect(json[:employees][0]).to eq({
+          expect(json[:employees][:nodes][0]).to eq({
             _type: "employees",
             firstName: "John",
-            positions: [{_type: "positions", title: "title1"}]
+            positions: {nodes: [{_type: "positions", title: "title1"}]}
           })
         end
       end
@@ -553,9 +553,9 @@ def self.name
         end
 
         it "is camelized" do
-          expect(json[:employees][0]).to eq({
+          expect(json[:employees][:nodes][0]).to eq({
             firstName: "John",
-            positions: [{multiWord: "foo"}]
+            positions: {nodes: [{multiWord: "foo"}]}
           })
         end
       end
@@ -575,7 +575,8 @@ def self.name
         end
 
         it "is camelized" do
-          expect(json[:employees][0][:importantPositions]).to eq([{
+          employee = json[:employees][:nodes][0]
+          expect(employee[:importantPositions][:nodes]).to eq([{
             rank: 1,
             title: "title1",
             importantDepartment: {

spec/schema_diff_spec.rb

@@ -891,6 +891,49 @@ def self.name
       end
     end
 
+    context "when a stat is added" do
+      before do
+        resource_a.stat age: [:sum]
+      end
+
+      it { is_expected.to eq([]) }
+    end
+
+    context "when a stat is removed" do
+      before do
+        resource_a.stat age: [:sum]
+        resource_b.config[:stats].delete(:age)
+      end
+
+      it "returns error" do
+        expect(diff).to eq([
+          "SchemaDiff::EmployeeResource: stat :age was removed."
+        ])
+      end
+    end
+
+    context "when a calculation is added" do
+      before do
+        resource_a.stat age: [:sum]
+        resource_b.stat age: [:sum, :average]
+      end
+
+      it { is_expected.to eq([]) }
+    end
+
+    context "when a calculation is removed" do
+      before do
+        resource_a.stat age: [:sum, :average]
+        resource_b.stat age: [:sum]
+      end
+
+      it "returns error" do
+        expect(diff).to eq([
+          "SchemaDiff::EmployeeResource: calculation :average was removed from stat :age."
+        ])
+      end
+    end
+
     context "when relationship is added" do
       before do
         resource_b.has_many :positions, resource: position_resource

spec/schema_spec.rb

@@ -31,6 +31,9 @@
               id: {},
               first_name: {}
             },
+            stats: {
+              total: [:count]
+            },
             filters: {
               id: {
                 type: "integer_id",
@@ -552,6 +555,19 @@ def self.name
       end
     end
 
+    context "when an additional statistic/calculations" do
+      before do
+        employee_resource.stat age: [:average, :sum]
+      end
+
+      it "is added to the schema" do
+        expect(schema[:resources][0][:stats]).to eq({
+          total: [:count],
+          age: [:average, :sum]
+        })
+      end
+    end
+
     context "when a default sort" do
       before do
         employee_resource.default_sort = [{foo: :asc}]