graphql-groups 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc6f31b4fca864cefe1967ddd17af2a65a782f53378f6b4c3bc5d7fb76a7819a
-  data.tar.gz: e64200c1a65480d32cdfb2826615e3ce8d26ae6fa61677e17a95a187c1b2063c
+  metadata.gz: d719d15bde5e54f543072d6b188540e38ef8eb1635c156af4f09a1b769fe59b0
+  data.tar.gz: 6e8b3a42ff5605c0a4fd99f4581982d4e52860cc51776a354881302c9eabd408
 SHA512:
-  metadata.gz: 697fab7612389337ab019a3820cffbf91546ac5ddf026903448b6f5eb6815f0c468225aebe10d3febcee88dcfd174903fa487ae6f83361ed91ec605c43b0e94a
-  data.tar.gz: 4c99e4cbe13c9fa4e80a7a8c7b0958c2127675ba1e94f501b280160f8b231eda19f1ffaf9dcdfbcb0304d3721d66d416833696c8cf2074cf1092b15010766867
+  metadata.gz: c99e16857d3c8450469a3e1ff18ac6ec38e4921108b689413a34b0bccf96f4682ab9827678129d6938188fd956fc93bf95ddab2b00490a630fbb6a48bc803349
+  data.tar.gz: 6f0464eff3da15b38bdab1ff27dda8e0131fa72936b567fdd1ad20a5e9fc7e2a390a05ef07afaa2e169dbd4c382cb41904e442f2ac41442df45f174fb045a79c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphql-groups (0.1.4)
+    graphql-groups (0.2.0)
       graphql (~> 1, > 1.9)
 
 GEM
@@ -36,6 +36,8 @@ GEM
       http (> 0.8, < 3.0)
       multi_json (~> 1)
     graphql (1.11.1)
+    groupdate (5.2.1)
+      activesupport (>= 5)
     gruff (0.10.0)
       histogram
       rmagick
@@ -114,6 +116,7 @@ DEPENDENCIES
   database_cleaner-active_record (~> 1.8)
   gqli (~> 1.0)
   graphql-groups!
+  groupdate (~> 5.2.1)
   gruff (~> 0.10)
   rake (~> 13.0)
   rspec (~> 3.0)

data/README.md

@@ -269,12 +269,11 @@ While it is possible to add grouping to your GraphQL schema by using `group_by`
 
 The benchmark queries the author count grouped by name, using an increasing number of authors. While the in-memory approach of grouping works well for a small number of records, it is outperformed quickly as that number increases.
 
-Benchmarks are generated using [benchmark-ips](https://github.com/evanphx/benchmark-ips). The benchmark script used to generate the report be found [here](./benchmark/benchmark.rb)
+Benchmarks can be generated by running `rake benchmark`. The benchmark script used to generate the report be found [here](./benchmark/benchmark.rb)
 
 ## Limitations and Known Issues
 
-*This gem is in early development!* There are a number of issues that are still being addressed. There is no guarantee
-that this libraries API will not change fundamentally from one release to the next. Please refer to the [issue tracker](https://github.com/hschne/graphql-groups/issues) for a list of known issues.
+Please refer to the [issue tracker](https://github.com/hschne/graphql-groups/issues) for a list of known issues.
 
 ## Credits
 

data/graphql-groups.gemspec

@@ -36,6 +36,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 2.0'
   spec.add_development_dependency 'database_cleaner-active_record', '~> 1.8'
   spec.add_development_dependency 'gqli', '~> 1.0'
+  spec.add_development_dependency 'groupdate', '~> 5.2.1'
   spec.add_development_dependency 'gruff', '~> 0.10'
   spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3.0'

data/lib/graphql/groups.rb

@@ -4,6 +4,7 @@ require 'graphql/groups/version'
 
 require 'graphql'
 
+require 'graphql/groups/utils'
 require 'graphql/groups/group_type_registry'
 require 'graphql/groups/schema/group_field'
 require 'graphql/groups/schema/aggregate_field'
@@ -15,9 +16,11 @@ require 'graphql/groups/has_groups'
 require 'graphql/groups/schema/group_result_type'
 require 'graphql/groups/schema/group_type'
 
-require 'graphql/groups/lookahead_parser'
+require 'graphql/groups/query_result'
+require 'graphql/groups/pending_query'
+require 'graphql/groups/query_builder_context'
+require 'graphql/groups/query_builder'
 require 'graphql/groups/result_transformer'
-require 'graphql/groups/executor'
 
 
 module GraphQL
@@ -31,10 +34,9 @@ module GraphQL
         field name, type, extras: [:lookahead], null: false, **options
 
         define_method name do |lookahead: nil|
-          execution_plan = GraphQL::Groups::LookaheadParser.parse(lookahead, context)
-          base_query = type.authorized_new(object, context).scope
-          results = Executor.call(base_query, execution_plan)
-          GraphQL::Groups::ResultTransformer.new.run(results)
+          pending_queries = QueryBuilder.parse(lookahead, object, context)
+          query_results = pending_queries.map(&:execute)
+          GraphQL::Groups::ResultTransformer.new.run(query_results)
         end
       end
     end

data/lib/graphql/groups/group_type_registry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'singleton'
 
 module GraphQL
@@ -11,6 +13,10 @@ module GraphQL
         @types = {}
       end
 
+      def clear
+        @types = {}
+      end
+
       def register(type, derived)
         types[type] = derived
       end

data/lib/graphql/groups/has_aggregates.rb

@@ -11,7 +11,6 @@ module GraphQL
         def aggregate(name, *_, **options, &block)
           aggregate_type = aggregate_type(name)
 
-          # TODO: Handle method name conflicts, or no query method found error
           resolve_method = "resolve_#{name}".to_sym
           query_method = options[:query_method] || name
           field = aggregate_field name, aggregate_type,
@@ -21,11 +20,8 @@ module GraphQL
                                   **options, &block
           aggregate_type.add_fields(field.own_attributes)
 
-          # TODO: Avoid overwriting existing method
-          define_method query_method do |**kwargs|
-            scope = kwargs[:scope]
-            attribute = kwargs[:attribute]
-            scope.public_send(name, attribute)
+          define_method query_method do |scope:, **kwargs|
+            scope.public_send(name, **kwargs)
           end
 
           define_method resolve_method do
@@ -42,7 +38,6 @@ module GraphQL
         private
 
         def aggregate_type(name)
-          # TODO: Handle no aggregate type found
           name = "#{name}AggregateType".upcase_first
           own_aggregate_types[name] ||= Class.new(Schema::AggregateType) do
             graphql_name name

data/lib/graphql/groups/has_groups.rb

@@ -17,28 +17,27 @@ module GraphQL
       module ClassMethods
         attr_reader :class_scope
 
-        # TODO: Error if there are no groupings defined
         def by(name, **options, &block)
           query_method = options[:query_method] || name
           resolver_method = "resolve_#{query_method}".to_sym
           group_field name, [own_result_type],
-                      null: false,
-                      resolver_method: resolver_method,
                       query_method: query_method,
+                      null: true,
+                      resolver_method: resolver_method,
+
                       **options, &block
 
           define_method query_method do |**kwargs|
             kwargs[:scope].group(name)
           end
 
-          # TODO: Warn / Disallow overwriting these resolver methods
           define_method resolver_method do |**_|
             group[name]
           end
         end
 
         def group_field(*args, **kwargs, &block)
-          field_defn = Schema::GroupField.from_options(*args, owner: self, **kwargs, &block)
+          field_defn = field_class.from_options(*args, owner: self, **kwargs, &block)
           add_field(field_defn)
           field_defn
         end
@@ -65,7 +64,21 @@ module GraphQL
             field :group_by, own_group_type, null: false, camelize: true
 
             def group_by
-              group_result[1][:nested]
+              group_result[1][:group_by]
+            end
+          end)
+        end
+
+        def own_field_type
+          type = "#{name}Field"
+          base_field_type = field_class
+          registry = GraphQL::Groups::GroupTypeRegistry.instance
+          registry.get(type) || registry.register(type, Class.new(base_field_type) do
+            attr_reader :query_method
+
+            def initialize(query_method:, **options, &definition_block)
+              @query_method = query_method
+              super(**options.except(:query_method), &definition_block)
             end
           end)
         end

data/lib/graphql/groups/pending_query.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Groups
+    class PendingQuery
+      attr_reader :key
+      attr_reader :aggregate
+      attr_reader :query
+
+      def initialize(key, aggregate, proc)
+        @key = Utils.wrap(key)
+        @aggregate = Utils.wrap(aggregate)
+        @query = proc
+      end
+
+      def execute
+        result = @query.call
+        QueryResult.new(@key, @aggregate, result)
+      end
+    end
+  end
+end

data/lib/graphql/groups/query_builder.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Groups
+    class QueryBuilder
+      def self.parse(lookahead, object, context)
+        QueryBuilder.new(lookahead, object, context).group_selections
+      end
+
+      def initialize(lookahead, object, context)
+        @lookahead = lookahead
+        @context = context
+        type = @lookahead.field.type.of_type
+        @base_query = proc { type.authorized_new(object, context).scope }
+        super()
+      end
+
+      def group_selections(lookahead = @lookahead, current_context = QueryBuilderContext.new([], @base_query))
+        selections = lookahead.selections
+        group_field_type = lookahead.field.type.of_type.field_class
+        group_selections = selections.select { |selection| selection.field.is_a?(group_field_type) }
+        queries = group_selections.each_with_object([]) do |selection, object|
+          field_proc = proc_from_selection(selection.field, selection.arguments)
+          context = current_context.update(selection.name, field_proc)
+          object << create_pending_queries(selection, context)
+        end
+        nested_queries = group_selections
+                           .filter { |selection| selection.selects?(:group_by) }
+                           .each_with_object([]) do |selection, object|
+          field_proc = proc_from_selection(selection.field, selection.arguments)
+          context = current_context.update(selection.name, field_proc)
+          object << group_selections(selection.selection(:group_by), context)
+        end
+        (queries + nested_queries).flatten
+      end
+
+      private
+
+      def create_pending_queries(current_selection, context)
+        aggregate_selections = current_selection
+                                 .selections
+                                 .select { |selection| selection.field.is_a?(GraphQL::Groups::Schema::AggregateField) }
+        count_queries = count_queries(aggregate_selections, context)
+        aggregate_queries = aggregate_queries(aggregate_selections, context)
+        (count_queries + aggregate_queries)
+      end
+
+      def count_queries(aggregate_selections, context)
+        # TODO: When getting multiple aggregates for the same base data we could do just a single query instead of many
+        aggregate_selections
+          .select { |selection| selection.name == :count }
+          .map do |selection|
+          field = selection.field
+          count_proc = proc { |scope| field.owner.send(:new, {}, nil).public_send(field.query_method, scope: scope) }
+          combined = combine_procs(context.current_proc, count_proc)
+          PendingQuery.new(context.grouping, selection.name, combined)
+        end
+      end
+
+      def aggregate_queries(aggregate_selections, context)
+        aggregate_selections
+          .select { |selection| selection.field.own_attributes.present? }
+          .map { |selection| attribute_queries(context, selection) }
+          .flatten
+      end
+
+      def attribute_queries(context, selection)
+        selection.field
+          .own_attributes
+          .select { |attribute| selection.selections.map(&:name).include?(attribute) }
+          .map do |attribute|
+          aggregate_proc = proc_from_attribute(selection.field, attribute, selection.arguments)
+          combined = combine_procs(context.current_proc, aggregate_proc)
+          PendingQuery.new(context.grouping, [selection.name, attribute], combined)
+        end
+      end
+
+      def combine_procs(base_proc, new_proc)
+        proc { new_proc.call(base_proc.call) }
+      end
+
+      def proc_from_selection(field, arguments)
+        proc { |scope| field.owner.authorized_new(nil, @context).public_send(field.query_method, scope: scope, **arguments) }
+      end
+
+      def proc_from_attribute(field, attribute, arguments)
+        proc do |scope|
+          field.owner.authorized_new(nil, @context)
+            .public_send(field.query_method,
+                         scope: scope,
+                         attribute: attribute, **arguments)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/groups/query_builder_context.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class QueryBuilderContext
+  attr_reader :grouping
+  attr_reader :current_proc
+
+  def initialize(groupings = [], current_proc = nil)
+    @grouping = groupings
+    @current_proc = current_proc
+  end
+
+  def update(grouping, new_proc)
+    new_grouping = @grouping + [grouping]
+    combined_proc = combine_procs(@current_proc, new_proc)
+    QueryBuilderContext.new(new_grouping, combined_proc)
+  end
+
+  def combine_procs(base_proc, new_proc)
+    proc { new_proc.call(base_proc.call) }
+  end
+end

data/lib/graphql/groups/query_result.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Groups
+    class QueryResult
+      attr_reader :key
+      attr_reader :aggregate
+      attr_reader :result_hash
+
+      def initialize(key, aggregate, result)
+        @key = Utils.wrap(key)
+        @aggregate = Utils.wrap(aggregate)
+        @result_hash = result
+      end
+    end
+  end
+end

data/lib/graphql/groups/result_transformer.rb

@@ -3,93 +3,47 @@
 module GraphQL
   module Groups
     class ResultTransformer
-      def run(results)
-        transform_results(results)
+      def run(query_results)
+        # Sort by key length so that deeper nested queries come later
+        query_results
+          .sort_by { |query_result| query_result.key.length }
+          .each_with_object({}) do |query_result, object|
+          transform_result(query_result, object)
+        end
       end
 
       private
 
-      def transform_results(results)
-        # Because group query returns its results in a way that is not usable by GraphQL we need to transform these
-        # results and merge them into a single dataset.
-        #
-        # The result of a group query usually is a hash where they keys are the values of the columns that were grouped
-        # and the values are the aggregates. What we want is a deep hash where each level contains the statistics for
-        # that level in regards to the parent level.
-        #
-        # It all makes a lot more sense if you look at the GraphQL interface for statistics :)
-        #
-        # We accomplish this by transforming each result set to a hash and then merging them into a single one.
-        results.each_with_object({}) { |(key, value), object| object.deep_merge!(transform_result(key, value)) }
-      end
-
-      def transform_result(key, result)
-        is_aggregate_result = result.values[0].values[0].is_a?(Hash)
-
-        transformed = result.each_with_object({}) do |(aggregate_key, aggregate_value), object|
-          if is_aggregate_result
-            transform_aggregate_result(aggregate_key, aggregate_value, key, object)
+      def transform_result(query_result, object)
+        keys = query_result.key
+        return object[keys[0]] = [] if query_result.result_hash.empty?
+
+        query_result.result_hash.each do |grouping_result|
+          group_result_keys = Utils.wrap(grouping_result[0])
+          group_result_value = grouping_result[1]
+          Utils.duplicate(keys, group_result_keys)
+          inner_hash = create_nested_result(keys, group_result_keys, object)
+          if query_result.aggregate.length == 1
+            inner_hash[query_result.aggregate[0]] = group_result_value
           else
-            object.deep_merge!(transform_aggregate(key, aggregate_key, aggregate_value))
+            aggregate_type = query_result.aggregate[0]
+            aggregate_attribute = query_result.aggregate[1]
+            inner_hash[aggregate_type] ||= {}
+            inner_hash[aggregate_type][aggregate_attribute] ||= group_result_value
           end
         end
-
-        transformed.presence || { key => [] }
-      end
-
-      def transform_aggregate_result(aggregate_key, aggregate_value, key, object)
-        aggregate_value.each do |attribute, value|
-          object.deep_merge!(transform_attribute(key, aggregate_key, attribute, value))
-        end
       end
 
-      def transform_aggregate(key, aggregate, result)
-        return {} unless result.present?
-
-        hashes = result.map do |(keys, value)|
-          with_zipped = build_keys(key, keys)
-          with_zipped.append(aggregate)
-          with_zipped.reverse.inject(value) { |a, n| { n => a } }
-        end
-
-        merge(hashes)
-      end
+      def create_nested_result(keys, group_result_keys, object)
+        head_key, *rest_keys = keys
+        head_group_key, *rest_group_keys = group_result_keys
+        object[head_key] ||= {}
+        object[head_key][head_group_key] ||= {}
+        inner_hash = object[head_key][head_group_key]
+        return inner_hash if rest_keys.empty?
 
-      def transform_attribute(key, aggregate, attribute, result)
-        return {} unless result.present?
-
-        hashes = result.map do |(keys, value)|
-          with_zipped = build_keys(key, keys)
-          with_zipped.append(aggregate)
-          with_zipped.append(attribute)
-          with_zipped.reverse.inject(value) { |a, n| { n => a } }
-        end
-        merge(hashes)
-      end
-
-      def merge(hashes)
-        hashes.each_with_object({}) do |hash, object|
-          object.deep_merge!(hash)
-        end
-      end
-
-      def build_keys(key, keys)
-        key = wrap(key)
-        keys = keys ? wrap(keys) : [nil]
-        nested = [:nested] * (key.length - 1)
-
-        with_zipped = key.zip(keys).zip(nested).flatten!
-        with_zipped.first(with_zipped.size - 1)
-      end
-
-      def wrap(object)
-        if object.nil?
-          []
-        elsif object.respond_to?(:to_ary)
-          object.to_ary || [object]
-        else
-          [object]
-        end
+        inner_hash[:group_by] ||= {}
+        create_nested_result(rest_keys, rest_group_keys, inner_hash[:group_by])
       end
     end
   end

data/lib/graphql/groups/schema/group_result_type.rb

@@ -21,7 +21,7 @@ module GraphQL
           group_result[0]
         end
 
-        def count(scope:, **_)
+        def count(scope:, **)
           scope.size
         end
 

data/lib/graphql/groups/schema/group_type.rb

@@ -10,8 +10,7 @@ module GraphQL
 
         alias group object
 
-        # TODO: Make group field inherit from default field, so that users default args/fields are respected
-        field_class(GroupField)
+        field_class(own_field_type)
       end
     end
   end

data/lib/graphql/groups/utils.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Groups
+    module Utils
+      class << self
+        def wrap(object)
+          if object.nil?
+            []
+          elsif object.respond_to?(:to_ary)
+            object.to_ary || [object]
+          else
+            [object]
+          end
+        end
+
+        # This is used by the resul transformer when the user executed a query where some groupings are repeated, so depth
+        # of the query doesn't match the length of the query result keys. We need to modify the result keys so everything
+        # matches again.
+        def duplicate(keys, values)
+          return if keys.length == values.length
+
+          duplicates = duplicates(keys)
+          return if duplicates.empty?
+
+          duplicates.each do |_, indices|
+            first_occurrence, *rest = indices
+            value_to_duplicate = values[first_occurrence]
+            rest.each { |index| values.insert(index, value_to_duplicate) }
+          end
+        end
+
+        private
+
+        def duplicates(array)
+          map = {}
+          duplicates = {}
+          array.each_with_index do |v, i|
+            map[v] = (map[v] || 0) + 1
+            duplicates[v] ||= []
+            duplicates[v] << i
+          end
+          duplicates.select { |_, v| v.length > 1 }
+        end
+
+      end
+    end
+  end
+end

data/lib/graphql/groups/version.rb

@@ -2,6 +2,6 @@
 
 module Graphql
   module Groups
-    VERSION = '0.1.4'
+    VERSION = '0.2.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-groups
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Hans-Jörg Schnedlitz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-08-26 00:00:00.000000000 Z
+date: 2021-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: groupdate
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.1
 - !ruby/object:Gem::Dependency
   name: gruff
   requirement: !ruby/object:Gem::Requirement
@@ -222,17 +236,20 @@ files:
 - bin/setup
 - graphql-groups.gemspec
 - lib/graphql/groups.rb
-- lib/graphql/groups/executor.rb
 - lib/graphql/groups/group_type_registry.rb
 - lib/graphql/groups/has_aggregates.rb
 - lib/graphql/groups/has_groups.rb
-- lib/graphql/groups/lookahead_parser.rb
+- lib/graphql/groups/pending_query.rb
+- lib/graphql/groups/query_builder.rb
+- lib/graphql/groups/query_builder_context.rb
+- lib/graphql/groups/query_result.rb
 - lib/graphql/groups/result_transformer.rb
 - lib/graphql/groups/schema/aggregate_field.rb
 - lib/graphql/groups/schema/aggregate_type.rb
 - lib/graphql/groups/schema/group_field.rb
 - lib/graphql/groups/schema/group_result_type.rb
 - lib/graphql/groups/schema/group_type.rb
+- lib/graphql/groups/utils.rb
 - lib/graphql/groups/version.rb
 homepage: https://github.com/hschne/graphql-groups
 licenses:

data/lib/graphql/groups/executor.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Groups
-    class Executor
-      class << self
-        def call(base_query, execution_plan)
-          execution_plan.each_with_object({}) do |(key, value), object|
-            object.merge!(execute(base_query, key, value))
-          end
-        end
-
-        def execute(scope, key, value)
-          group_query = value[:proc].call(scope: scope)
-          results = value[:aggregates].each_with_object({}) do |(aggregate_key, aggregate), object|
-            if aggregate_key == :count
-              object[:count] = aggregate[:proc].call(scope: group_query)
-            else
-              object[aggregate_key] ||= {}
-              aggregate[:attributes].each do |attribute|
-                result = aggregate[:proc].call(scope: group_query, attribute: attribute)
-                object[aggregate_key][attribute] = result
-              end
-            end
-          end
-
-          results = { key => results }
-          return results unless value[:nested]
-
-          value[:nested].each do |inner_key, inner_value|
-            new_key = (Array.wrap(key) << inner_key)
-            inner_result = execute(group_query, inner_key, inner_value)
-            results[new_key] = inner_result[inner_key]
-          end
-          results
-        end
-      end
-    end
-  end
-end

data/lib/graphql/groups/lookahead_parser.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Groups
-    class LookaheadParser
-      def self.parse(base_selection, context)
-        # TODO: Raise error if no aggregate selection is made
-        LookaheadParser.new(context).group_selections(base_selection, {})
-      end
-
-      def initialize(context)
-        @context = context
-      end
-
-      def group_selections(root, hash)
-        selections = root.selections
-        group_selections = selections.select { |selection| selection.field.is_a?(GraphQL::Groups::Schema::GroupField) }
-        group_selections.each do |selection|
-          own_query = get_field_proc(selection.field, selection.arguments)
-          hash[selection.name] ||= { proc: own_query }
-          hash[selection.name][:aggregates] = aggregates(selection)
-        end
-        group_selections
-          .filter { |selection| selection.selects?(:group_by) }
-          .each { |selection| hash[selection.name][:nested] = group_selections(selection.selection(:group_by), {}) }
-        hash
-      end
-
-      def get_field_proc(field, arguments)
-        proc { |**kwargs| field.owner.authorized_new(nil, @context).public_send(field.query_method, **arguments, **kwargs) }
-      end
-
-      def aggregates(group_selection)
-        aggregate_selections = group_selection.selections.select do |selection|
-          selection.field.is_a?(GraphQL::Groups::Schema::AggregateField)
-        end
-        aggregate_selections.each_with_object({}) do |selection, object|
-          name = selection.name
-          field = selection.field
-          if name == :count
-            proc = proc { |**kwargs| field.owner.send(:new, {}, nil).public_send(field.query_method, **kwargs) }
-            object[name] = { proc: proc }
-          elsif selection.field.own_attributes.present?
-            object[name] = { proc: get_aggregate_proc(field, selection.arguments), attributes: field.own_attributes }
-          end
-        end
-      end
-
-      def get_aggregate_proc(field, arguments)
-        proc { |**kwargs| field.owner.authorized_new(nil, @context).send(field.query_method, **kwargs, **arguments) }
-      end
-    end
-  end
-end