graphql-groups 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46969188f84ff7921fee98bfad6f6264125bcce523dfcb7c93550eb1755a3951
-  data.tar.gz: f6a925a6c8037b42a134fca19d5d0d631656bdd3ec3a8a963fcfe95dbfbf16e9
+  metadata.gz: c30a036d32f2580c7dbbbd4ee10d8cc364e8dc4af0e92fc5d0ab1d3c8378f55e
+  data.tar.gz: fcd1bb1beeaed5247eba94cb72ac3418d3f29ca19a839ff78ed83e1b86aa602b
 SHA512:
-  metadata.gz: 450065ae2c4f015adc736241d1a917cdc65ceaa122305db706f6b138263cbbdf32c1636b7ad2017d058ff4c2276c970a4896e471015badbabbc5ee72aca3be01
-  data.tar.gz: 81da40cf05c3b6b284858037baee1b9402ef38eaeb4559315784e4fbfd2f6d8a5f7897dabbf981f4a5fd220d5ee66fb06dc89fd8e785202951ca0edb22d69f3b
+  metadata.gz: 8bbde25d65f689d6b2127761e1b535d1d1946bdedd569707498e4516d33d69da76b7efc9d34bb9bd41212b6822f195188c39556a88ad0d85a75e6eb34fbce93c
+  data.tar.gz: 43acc2931f89122b3e23f20e181cb8ab9e02d979bfd9153554d1f72b4a27a81a9ae722b975342e9ab37e5a930b2a2b777af97af8249ad74bfad293c93efbbf62

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphql-groups (0.1.1)
+    graphql-groups (0.1.3)
       graphql (~> 1, > 1.9)
 
 GEM
@@ -36,6 +36,8 @@ GEM
       http (> 0.8, < 3.0)
       multi_json (~> 1)
     graphql (1.11.1)
+    groupdate (5.1.0)
+      activesupport (>= 5)
     gruff (0.10.0)
       histogram
       rmagick
@@ -89,12 +91,15 @@ GEM
       parser (>= 2.7.0.1)
     rubocop-rspec (1.42.0)
       rubocop (>= 0.87.0)
+    ruby-prof (1.4.1)
     ruby-progressbar (1.10.1)
     simplecov (0.18.5)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
     simplecov-html (0.12.2)
     sqlite3 (1.4.2)
+    stackprof (0.2.15)
+    test-prof (0.12.0)
     thread_safe (0.3.6)
     tzinfo (1.2.7)
       thread_safe (~> 0.1)
@@ -114,13 +119,17 @@ DEPENDENCIES
   database_cleaner-active_record (~> 1.8)
   gqli (~> 1.0)
   graphql-groups!
+  groupdate
   gruff (~> 0.10)
   rake (~> 13.0)
   rspec (~> 3.0)
   rubocop (~> 0.88)
   rubocop-rspec (~> 1.42)
+  ruby-prof
   simplecov (~> 0.18.5)
   sqlite3 (~> 1.4.2)
+  stackprof
+  test-prof
 
 BUNDLED WITH
    2.1.4

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 
@@ -262,9 +278,9 @@ that this libraries API will not change fundamentally from one release to the ne
 
 ## 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

@@ -8,7 +8,7 @@ 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'

data/lib/graphql/groups.rb

@@ -31,7 +31,7 @@ module GraphQL
         field name, type, extras: [:lookahead], null: false, **options
 
         define_method name do |lookahead: nil|
-          execution_plan = GraphQL::Groups::LookaheadParser.parse(lookahead)
+          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)

data/lib/graphql/groups/lookahead_parser.rb

@@ -3,8 +3,13 @@
 module GraphQL
   module Groups
     class LookaheadParser
-      def self.parse(base_selection)
-        LookaheadParser.new.group_selections(base_selection, {})
+      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)
@@ -22,8 +27,7 @@ module GraphQL
       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) }
+        proc { |**kwargs| field.owner.authorized_new(nil, @context).public_send(field.query_method, **arguments, **kwargs) }
       end
 
       def aggregates(group_selection)
@@ -43,8 +47,7 @@ module GraphQL
       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) }
+        proc { |**kwargs| field.owner.authorized_new(nil, @context).send(field.query_method, **kwargs, **arguments) }
       end
     end
   end

data/lib/graphql/groups/result_transformer.rb

@@ -10,12 +10,12 @@ module GraphQL
       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.
+        # 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.
+        # 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 :)
         #
@@ -24,11 +24,11 @@ module GraphQL
       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 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
+          if is_aggregate_result
+            transform_aggregate_result(aggregate_key, aggregate_value, key, object)
           else
             object.deep_merge!(transform_aggregate(key, aggregate_key, aggregate_value))
           end
@@ -37,24 +37,44 @@ module GraphQL
         transformed.presence || { key => [] }
       end
 
-      # TODO: Merge transform aggregate and transform attribute
+      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)
-        result.each_with_object({}) do |(keys, value), object|
+        return {} unless result.present?
+
+        hashes = result.map do |(keys, value)|
           with_zipped = build_keys(key, keys)
           with_zipped.append(aggregate)
-          hash = with_zipped.reverse.inject(value) { |a, n| { n => a } }
-          object.deep_merge!(hash)
+          with_zipped.reverse.inject(value) { |a, n| { n => a } }
         end
+
+        merge(hashes)
       end
 
       def transform_attribute(key, aggregate, attribute, result)
-        result.each_with_object({}) do |(keys, value), object|
+        return {} unless result.present?
+
+        hashes = result.map do |(keys, value)|
           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)
+          with_zipped.reverse.inject(value) { |a, n| { n => a } }
+        end
+        merge(hashes)
+      end
+
+      def merge(hashes)
+        root_key = hashes.first.keys.first
+        result = hashes.each_with_object({}) do |hash, object|
+          inner = hash[root_key]
+          inner_key = inner.keys.first
+          object[inner_key] = inner.values.first
         end
+        { root_key => result }
       end
 
       def build_keys(key, keys)

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

@@ -1,5 +1,5 @@
 module Graphql
   module Groups
-    VERSION = '0.1.2'.freeze
+    VERSION = '0.1.3'.freeze
   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.1.3
 platform: ruby
 authors:
 - Hans-Jörg Schnedlitz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-07-30 00:00:00.000000000 Z
+date: 2020-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -263,5 +263,5 @@ requirements: []
 rubygems_version: 3.0.3
 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: []