graphql-groups 0.1.2 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46969188f84ff7921fee98bfad6f6264125bcce523dfcb7c93550eb1755a3951
-  data.tar.gz: f6a925a6c8037b42a134fca19d5d0d631656bdd3ec3a8a963fcfe95dbfbf16e9
+  metadata.gz: 402086494f2bba5acc764ad745f9083b13b1f9986f43c9717fb511647c51aa11
+  data.tar.gz: 043ea5a04163d20f31b7ea6becac5da0dfda5b3d9721b97798acabb2bd8a9974
 SHA512:
-  metadata.gz: 450065ae2c4f015adc736241d1a917cdc65ceaa122305db706f6b138263cbbdf32c1636b7ad2017d058ff4c2276c970a4896e471015badbabbc5ee72aca3be01
-  data.tar.gz: 81da40cf05c3b6b284858037baee1b9402ef38eaeb4559315784e4fbfd2f6d8a5f7897dabbf981f4a5fd220d5ee66fb06dc89fd8e785202951ca0edb22d69f3b
+  metadata.gz: 90e97ff34a842f148d49fcaa6c39bd6605c32bbe9f19e7f7b1d9d2b6ac3562da4fdfb1deff38fe110c83b980229225c45ceff75b3f97d14e0f71791eba610862
+  data.tar.gz: 5b561e1e307a1a9618316f4bf695bc96273dd67e156f629ddf3a4cc5a9fdf3d60ada09fce0857b3fdf9575ce1b7425c08864163561d4c18f0912eb2a22a6ec56

data/Gemfile.lock

@@ -1,28 +1,28 @@
 PATH
   remote: .
   specs:
-    graphql-groups (0.1.1)
+    graphql-groups (0.2.0)
       graphql (~> 1, > 1.9)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (6.0.3.2)
-      activesupport (= 6.0.3.2)
-    activerecord (6.0.3.2)
-      activemodel (= 6.0.3.2)
-      activesupport (= 6.0.3.2)
-    activesupport (6.0.3.2)
+    activemodel (6.1.3)
+      activesupport (= 6.1.3)
+    activerecord (6.1.3)
+      activemodel (= 6.1.3)
+      activesupport (= 6.1.3)
+    activesupport (6.1.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-      zeitwerk (~> 2.2, >= 2.2.2)
-    addressable (2.7.0)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    addressable (2.8.0)
       public_suffix (>= 2.0.2, < 5.0)
     ast (2.4.1)
     benchmark-ips (2.8.2)
-    concurrent-ruby (1.1.6)
+    concurrent-ruby (1.1.8)
     database_cleaner (1.8.5)
     database_cleaner-active_record (1.8.0)
       activerecord
@@ -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
@@ -50,18 +52,18 @@ GEM
       domain_name (~> 0.5)
     http-form_data (1.0.3)
     http_parser.rb (0.6.0)
-    i18n (1.8.3)
+    i18n (1.8.9)
       concurrent-ruby (~> 1.0)
-    minitest (5.14.1)
+    minitest (5.14.4)
     multi_json (1.15.0)
     parallel (1.19.2)
     parser (2.7.1.4)
       ast (~> 2.4.1)
-    public_suffix (4.0.5)
+    public_suffix (4.0.6)
     rainbow (3.0.0)
     rake (13.0.1)
     regexp_parser (1.7.1)
-    rexml (3.2.4)
+    rexml (3.2.5)
     rmagick (4.1.2)
     rspec (3.9.0)
       rspec-core (~> 3.9.0)
@@ -95,14 +97,13 @@ GEM
       simplecov-html (~> 0.11)
     simplecov-html (0.12.2)
     sqlite3 (1.4.2)
-    thread_safe (0.3.6)
-    tzinfo (1.2.7)
-      thread_safe (~> 0.1)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
     unf (0.1.4)
       unf_ext
     unf_ext (0.0.7.7)
     unicode-display_width (1.7.0)
-    zeitwerk (2.4.0)
+    zeitwerk (2.4.2)
 
 PLATFORMS
   ruby
@@ -114,6 +115,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

@@ -5,7 +5,7 @@
 [![Maintainability](https://api.codeclimate.com/v1/badges/692d4125ac8548fb145e/maintainability)](https://codeclimate.com/github/hschne/graphql-groups/maintainability) 
 [![Test Coverage](https://api.codeclimate.com/v1/badges/692d4125ac8548fb145e/test_coverage)](https://codeclimate.com/github/hschne/graphql-groups/test_coverage)
 
-Statistics and aggregates built on top of [graphql-ruby](https://github.com/rmosolgo/graphql-ruby).
+Run group- and aggregation queries with [graphql-ruby](https://github.com/rmosolgo/graphql-ruby).
 
 ## Installation
 
@@ -20,13 +20,12 @@ $ bundle install
 
 ## Usage
 
-Create a new group type to specify which attributes you wish to group by inheriting from `GraphQL::Groups::GroupType`:
+Suppose you want to get the number of authors, grouped by their age. Create a new group type by inheriting from `GraphQL::Groups::GroupType`:
 
 ```ruby
-class AuthorGroupType < GraphQL::Groups::GroupType
+class AuthorGroupType < GraphQL::Groups::Schema::GroupType
   scope { Author.all }
 
-  by :name
   by :age
 end
 ```
@@ -37,15 +36,14 @@ Include the new type in your schema using the `group` keyword, and you are done.
 class QueryType < GraphQL::Schema::Object
   include GraphQL::Groups
 
-  group :author_groups, AuthorGroupType
+  group :author_group_by, AuthorGroupType
 end
 ```
 
-You can then run a query to retrieve statistical information about your data, for example the number of authors per age.
-
+You can then run the following query to retrieve the number of authors per age. 
 ```graphql
 query myQuery{ 
-  authorGroups {
+  authorGroupBy {
     age {
       key
       count
@@ -55,7 +53,7 @@ query myQuery{
 ```
 ```json
 {
-  "authorGroups":{
+  "authorGroupBy":{
     "age":[
       {
         "key":"31",
@@ -71,18 +69,21 @@ query myQuery{
 }
 ```
 
+
 ## Why? 
 
-`graphql-ruby` lacks a built in way to query statistical data of collections. It is possible to add this functionality by
-using `group_by` (see for example [here](https://dev.to/gopeter/how-to-add-a-groupby-field-to-your-graphql-api-1f2j)), 
-but this performs poorly for large amounts of data. 
+`graphql-ruby` lacks a built in way to retrieve statistical data, such as counts or averages. It is possible to implement custom queries that provide  this functionality by using `group_by` (see for example [here](https://dev.to/gopeter/how-to-add-a-groupby-field-to-your-graphql-api-1f2j)), but this performs poorly for large amounts of data. 
+
+`graphql-groups` allows you to write flexible, readable queries while leveraging your database to aggreate data. It does so by performing an AST analysis on your request and executing exactly the database queries needed to fulfill it. This performs much better than grouping and aggregating in memory. See [performance](#Performance) for a benchmark.
 
-`graphql-groups` allows you to write flexible, readable queries while leveraging your database to group and
-aggregate data. See [performance](#Performance) for a benchmark.
 
 ## Advanced Usage
 
-#### Grouping by Multiple Attributes
+For a showcase of what you can do with `graphql-groups` check out [graphql-groups-demo](https://github.com/hschne/graphql-groups-demo) 
+
+Find a hosted version of the demo app [on Heroku](https://graphql-groups-demo.herokuapp.com/). 
+
+### Grouping by Multiple Attributes
 
 This library really shines when you want to group by multiple attributes, or otherwise retrieve complex statistical information
 within a single GraphQL query. 
@@ -134,7 +135,7 @@ query myQuery{
 
 `graphql-groups` will automatically execute the required queries and return the results in a easily parsable response.
 
-#### Custom Grouping Queries
+### Custom Grouping Queries
 
 To customize which queries are executed to group items, you may specify the grouping query by creating a method of the same name in the group type.
 
@@ -150,7 +151,7 @@ class AuthorGroupType < GraphQL::Groups::Schema::GroupType
 end
 ```
 
-You may also pass arguments to custom grouping queries. In this case, pass any arguments to your group query as keyword arguments.
+You may also pass arguments to custom grouping queries. In this case, pass any arguments to your group query as keyword arguments. 
 
 ```ruby
 class BookGroupType < GraphQL::Groups::Schema::GroupType
@@ -173,6 +174,23 @@ class BookGroupType < GraphQL::Groups::Schema::GroupType
 end
 ```
 
+You may access the query `context` in custom queries. As opposed to resolver methods accessing `object` is not possible and will raise an error. 
+
+```ruby
+class BookGroupType < GraphQL::Groups::Schema::GroupType
+  scope { Book.all }
+
+  by :list_price
+
+  def list_price(scope:)
+    currency = context[:currency] || ' $'
+    scope.group("list_price || ' #{currency}'")
+  end
+end
+```
+
+### Custom Scopes
+
 When defining a group type's scope you may access the parents `object` and `context`. 
 
 ```ruby
@@ -198,8 +216,6 @@ class BookGroupType < GraphQL::Groups::Schema::GroupType
 end
 ```
 
-For more examples see the [feature spec](./spec/graphql/feature_spec.rb) and [test schema](./spec/graphql/support/test_schema.rb)
-
 ### Custom Aggregates
 
 Per default `graphql-groups` supports aggregating `count` out of the box. If you need to other aggregates, such as sum or average 
@@ -253,18 +269,17 @@ 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
 
-![Meister](meister.png)
+<a href="https://www.meisterlabs.com"><img src="Meister.png" width="50%"></a>
 
-graphql-groups is supported by and battle-tested at [Meister](https://www.meisterlabs.com/)
+[graphql-groups](https://github.com/hschne/graphql-groups) was created at [meister](https://www.meisterlabs.com/)
 
 ## Development
 

data/graphql-groups.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'graphql/groups/version'
@@ -8,10 +10,10 @@ Gem::Specification.new do |spec|
   spec.authors = ['Hans-Jörg Schnedlitz']
   spec.email = ['hans.schnedlitz@gmail.com']
 
-  spec.summary = 'Create flexible and performant aggregation queries with graphql-ruby'
+  spec.summary = 'Create flexible and fast aggregation queries with graphql-ruby'
   spec.description = <<~HEREDOC
     GraphQL Groups makes it easy to add aggregation queries to your GraphQL schema. It combines a simple, flexible 
-    schema definition with high performance'
+    schema definition with high performance
   HEREDOC
   spec.homepage = 'https://github.com/hschne/graphql-groups'
   spec.license = 'MIT'
@@ -22,18 +24,21 @@ Gem::Specification.new do |spec|
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|benchmark|.github)/}) }
   end
   spec.bindir = 'exe'
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.6.0')
+
   spec.add_development_dependency 'activerecord', '~> 6.0'
   spec.add_development_dependency 'benchmark-ips', '~> 2.8'
   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/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,77 +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)
-        transformed = result.each_with_object({}) do |(aggregate_key, aggregate_value), object|
-          if aggregate_value.values.any? { |x| x.is_a?(Hash) }
-            aggregate_value.each do |attribute, value|
-              object.deep_merge!(transform_attribute(key, aggregate_key, attribute, value))
-            end
+      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
 
-      # TODO: Merge transform aggregate and transform attribute
-      def transform_aggregate(key, aggregate, result)
-        result.each_with_object({}) do |(keys, value), object|
-          with_zipped = build_keys(key, keys)
-          with_zipped.append(aggregate)
-          hash = with_zipped.reverse.inject(value) { |a, n| { n => a } }
-          object.deep_merge!(hash)
-        end
-      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)
-        result.each_with_object({}) do |(keys, value), object|
-          with_zipped = build_keys(key, keys)
-          with_zipped.append(aggregate)
-          with_zipped.append(attribute)
-          hash = with_zipped.reverse.inject(value) { |a, n| { n => a } }
-          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_field.rb

@@ -7,7 +7,6 @@ module GraphQL
         attr_reader :query_method
 
         def initialize(query_method:, **options, &definition_block)
-          # TODO: Make sure that users can access the context in custom query methods
           @query_method = query_method
           super(**options, &definition_block)
         end

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

@@ -13,15 +13,13 @@ module GraphQL
 
         field :key, String, null: true
 
-        field :count, Integer, null: false
-
         aggregate_field :count, Integer, null: false, query_method: :count, resolver_method: :resolve_count
 
         def key
           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

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Graphql
   module Groups
-    VERSION = '0.1.2'.freeze
+    VERSION = '0.2.1'
   end
 end

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)
-          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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-groups
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.1
 platform: ruby
 authors:
 - Hans-Jörg Schnedlitz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-07-30 00:00:00.000000000 Z
+date: 2021-11-29 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
@@ -199,14 +213,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.9'
 description: "GraphQL Groups makes it easy to add aggregation queries to your GraphQL
-  schema. It combines a simple, flexible \nschema definition with high performance'\n"
+  schema. It combines a simple, flexible \nschema definition with high performance\n"
 email:
 - hans.schnedlitz@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/workflows/build.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
@@ -219,24 +232,24 @@ files:
 - Meister.png
 - README.md
 - Rakefile
-- benchmark/benchmark.jpg
-- benchmark/benchmark.rb
-- benchmark/benchmark_schema.rb
 - bin/console
 - 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:
@@ -253,15 +266,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.3.1
 signing_key:
 specification_version: 4
-summary: Create flexible and performant aggregation queries with graphql-ruby
+summary: Create flexible and fast aggregation queries with graphql-ruby
 test_files: []

data/.github/workflows/build.yml

@@ -1,28 +0,0 @@
-name: Build
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Set up Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: 2.6.5
-      - name: Install dependencies
-        run: bundle install
-      - name: Run tests
-        run: bundle exec rspec
-      - name: Report coverage
-        uses: paambaati/codeclimate-action@v2.6.0
-        env:
-          CC_TEST_REPORTER_ID: ${{secrets.CC_TEST_REPORTER_ID}}
-        with:
-          # Coverage is already generated in test step, need to run anything again
-          coverageCommand: echo '' > /dev/null

data/benchmark/benchmark.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-require 'graphql/groups'
-
-require 'database_cleaner/active_record'
-require 'gqli/dsl'
-require 'benchmark/ips'
-require 'gruff'
-
-require_relative '../spec/graphql/support/test_schema/db'
-require_relative '../spec/graphql/support/test_schema/models'
-require_relative 'benchmark_schema'
-
-class Compare
-  def run
-    puts 'Generating reports...'
-    datasets = perform_runs
-    labels = { 0 => '10', 1 => '100', 2 => '1000', 3 => '10000' }
-    puts 'Generating graph...'
-    graph = graph(labels, datasets)
-    graph.write('benchmark/benchmark.jpg')
-    puts 'Done!'
-  end
-
-  private
-
-  def perform_runs
-    runs = [10, 100, 1000, 10_000]
-    runs.map { |count| single_run(count) }
-      .map(&:data)
-      .map { |data| { groups: data.first[:ips], group_by: data.second[:ips] } }
-      .each_with_object({ groups: [], group_by: [] }) do |item, object|
-      object[:groups].push(item[:groups])
-      object[:group_by].push(item[:group_by])
-    end
-  end
-
-  def graph(labels, datasets)
-    g = Gruff::Bar.new(800)
-    g.title = 'graphql-groups vs group_by'
-    g.theme = Gruff::Themes::THIRTYSEVEN_SIGNALS
-    g.labels = labels
-    g.x_axis_label = 'records'
-    g.y_axis_label = 'iterations/second'
-    datasets.each do |data|
-      g.data(data[0], data[1])
-    end
-    g
-  end
-
-  def single_run(count)
-    DatabaseCleaner.strategy = :transaction
-    DatabaseCleaner.start
-    seed(count)
-    report = run_benchmark
-    DatabaseCleaner.clean
-    report
-  end
-
-  def seed(count)
-    names = %w[Ada Alice Bob Bruce]
-    count.times { Author.create(name: names.sample) }
-  end
-
-  def groups_query
-    GQLi::DSL.query {
-      fastGroups {
-        name {
-          key
-          count
-        }
-      }
-    }.to_gql
-  end
-
-  def naive_query
-    GQLi::DSL.query {
-      slowGroups {
-        name {
-          key
-          count
-        }
-      }
-    }.to_gql
-  end
-
-  def run_benchmark
-    Benchmark.ips(quiet: true) do |x|
-      # Configure the number of seconds used during
-      # the warmup phase (default 2) and calculation phase (default 5)
-      x.config(time: 2, warmup: 1)
-
-      x.report('groups') { PerformanceSchema.execute(groups_query) }
-
-      x.report('group-by') { PerformanceSchema.execute(naive_query) }
-
-      # Compare the iterations per second of the various reports!
-      x.compare!
-    end
-  end
-end

data/benchmark/benchmark_schema.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'graphql'
-require 'graphql/groups'
-
-class BaseType < GraphQL::Schema::Object; end
-
-class AuthorGroupType < GraphQL::Groups::Schema::GroupType
-  scope { Author.all }
-
-  by :name
-end
-
-class SlowAuthorGroupResultType < GraphQL::Schema::Object
-  field :key, String, null: false
-  field :count, Integer, null: false
-
-  def key
-    object[0]
-  end
-
-  def count
-    object[1].size
-  end
-end
-
-class SlowAuthorGroupType < GraphQL::Schema::Object
-  field :name, [SlowAuthorGroupResultType], null: false
-
-  def name
-    object.group_by(&:name)
-  end
-end
-
-class QueryType < BaseType
-  include GraphQL::Groups
-
-  group :fast_groups, AuthorGroupType, camelize: true
-
-  field :slow_groups, SlowAuthorGroupType, null: false, camelize: true
-
-  def slow_groups
-    Author.all
-  end
-end
-
-class PerformanceSchema < GraphQL::Schema
-  query QueryType
-
-  def self.resolve_type(_type, obj, _ctx)
-    "#{obj.class.name}Type"
-  end
-end

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,51 +0,0 @@
-# frozen_string_literal: true
-
-module GraphQL
-  module Groups
-    class LookaheadParser
-      def self.parse(base_selection)
-        LookaheadParser.new.group_selections(base_selection, {})
-      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)
-        # TODO: Use authorized instead of using send to circument protection
-        proc { |**kwargs| field.owner.send(:new, {}, nil).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)
-        # TODO: Use authorized instead of using send to circument protection
-        proc { |**kwargs| field.owner.send(:new, {}, nil).send(field.query_method, **kwargs, **arguments) }
-      end
-    end
-  end
-end