graphql_preload_queries 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc56d2e745351d747e3bf8d1950761271b0bafea51732bbff4bc88af59f7cc51
-  data.tar.gz: 290fea98e4ef1b1f1d1d5ae94a07be35409b314a5c1ce7ca98b38580baffcbd0
+  metadata.gz: fcc53358f8564b5b00d02cf7a341a7a82af9a9f02db2458fa4902f16d10847fb
+  data.tar.gz: 959b2a80b05637e60127762fae8fc765fff6c28c5438099cefbbe40c2c37a8c6
 SHA512:
-  metadata.gz: f857c894b252512962d6488bc131b19e3b91b3ea89845d644604bd93aa4503f192673b1e45ef4f2619726d02e740d0e9086eed88c3142d7f2f4ab2cd1e0137b3
-  data.tar.gz: 9a10333cf145142d5e57890da59a90f2fc4ea755a2c0e412e8269e531850b62f132e63e5fe0eb5ff064f85c70fc6d26ebea7164badd73ce4177c688b172877e8
+  metadata.gz: 12797d60fbcdb9d528a56563d29b22c14555de16f4d0e34d063efc48444ec9e0936e854f5cf4912b7575720b40f7f79bfee25ab0b13039f9276efad5b99591e1
+  data.tar.gz: 991bb3d2cf4c6a8ccc2df2ce26f48cf564d6a37c6bc5f4a68a0d8de8a6d8ae8c48b62a4595b800dd62f72dcca180a31f23e3c28d0025625e76dea6c1f758961d

data/.github/workflows/ruby.yml

@@ -45,4 +45,5 @@ jobs:
         run: |
           bundle exec rspec
       - name: Code style (Rubocop)
-        run: bundle exec rubocop
+        run: bundle exec rubocop
+        if: matrix.ruby == '2.5'

data/.rubocop.yml

@@ -2,7 +2,7 @@
 
 require: rubocop-rspec
 AllCops:
-  TargetRubyVersion: 2.4
+  TargetRubyVersion: 2.5
 
 RSpec/FilePath:
   Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,24 @@
+## 0.4.0 (30-05-2021)
+- feat: refactor `include_gql_preloads` to auto calculate `query_key` and make it optional
+- feat: support `:preload` option when defining a field
+
+## 0.3.1 (22-01-2021)
+- feat: auto camelize key for queries and mutations
+
+## 0.3 (22-01-2021)
+- feat: add debug mode
+    ```GraphqlPreloadQueries::DEBUG = true```
+- fix: detect the correct Query Result Type
+
+## 0.2.2 (21-01-2021)
+- Fix: Fix deep recursive stack error
+
+## 0.2.1 (21-01-2021)
+- fix: add default preload to key
+- fix: fix invalid key when deep preloading
+
+## 0.2.0 (02-12-2020)
+- Refactor: Preload associations when iterating activeRecord::Relation
+
+## 0.1.0 (10-11-2020
+- Add rails query preload support for queries, mutations and gql object types. 

data/Gemfile

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+ruby '2.6.5'
 source 'https://rubygems.org'
 git_source(:github) { |repo| "https://github.com/#{repo}.git" }
 
@@ -7,6 +8,7 @@ git_source(:github) { |repo| "https://github.com/#{repo}.git" }
 # Bundler will treat runtime dependencies like base dependencies, and
 # development dependencies will be added by default to the :development group.
 gemspec
+gem 'byebug'
 
 # Declare any dependencies that are still in development here instead of in
 # your gemspec. These might include edge Rails or gems from your path or

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphql_preload_queries (0.2.0)
+    graphql_preload_queries (0.4.0)
       graphql
       rails
 
@@ -65,6 +65,7 @@ GEM
       zeitwerk (~> 2.2, >= 2.2.2)
     ast (2.4.1)
     builder (3.2.4)
+    byebug (11.1.3)
     concurrent-ruby (1.1.7)
     crass (1.0.6)
     database_cleaner (1.8.5)
@@ -86,11 +87,13 @@ GEM
     marcel (0.3.3)
       mimemagic (~> 0.3.2)
     method_source (1.0.0)
-    mimemagic (0.3.5)
-    mini_mime (1.0.2)
+    mimemagic (0.3.10)
+      nokogiri (~> 1)
+      rake
+    mini_mime (1.1.0)
     mini_portile2 (2.4.0)
     minitest (5.14.2)
-    nio4r (2.5.4)
+    nio4r (2.5.7)
     nokogiri (1.10.10)
       mini_portile2 (~> 2.4.0)
     parallel (1.20.1)
@@ -183,6 +186,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  byebug
   database_cleaner-active_record
   graphql_preload_queries!
   rspec-rails
@@ -190,5 +194,8 @@ DEPENDENCIES
   rubocop-rspec
   sqlite3
 
+RUBY VERSION
+   ruby 2.6.5p114
+
 BUNDLED WITH
    2.1.4

data/README.md

@@ -1,49 +1,51 @@
 # GraphqlPreloadQueries
-This gem helps you to define all nested preloads to be added when required for graphql data results and avoid the common problem "N+1 Queries". 
+This gem permits your graphql application to define association preloads to improve app performance by removing N+1 query issues. 
 
 ## Usage
   * Object Type
     ```ruby
     class UserType < Types::BaseObject
-      add_preload 'parents|allParents', { preload: :parents, friends: :friends, parents: :parents }
-      add_preload :friends, { parents: { preload: :parents, parents: :parents, friends: :friends } }
-    
       field :id, Int, null: true
       field :name, String, null: true
-      field :friends, [Types::UserType], null: false
-      field :parents, [Types::UserType], null: false
+      field :parents, [Types::UserType], null: false, preload: true
+      field :friends, [Types::UserType], null: false, preload: :user_friends
     end
     ```
-    Examples:
-    * ```add_preload :friends```
-      ```:friends``` association will be preloaded if query includes ```friends```, like: ```user(id: 10) { friends { ... } }```
-    
-    * ```add_preload :allFriends, :friends```
-      ```:friends``` association will be preloaded if query includes ```allFriends```, like: ```user(id: 10) { allFriends { ... } }```  
-    
-    * ```add_preload :allFriends, { preload: :friends, parents: :parents }```
-      ```:preload``` key can be used to indicate the association name when defining nested preloads, like: ```user(id: 10) { allFriends { id parents { ... } } }```  
-    
-    * ```add_preload :friends, { allParents: :parents }```
-      (Nested 1 lvl preloading) ```friends: :parents``` association will be preloaded if query includes ```allParents```, like: ```user(id: 10) { friends { allParents { ... } } }```  
     
-    * ```add_preload :friends, { allParents: { preload: :parents, friends: :friends } }```
-      (Nested 2 levels preloading) ```friends: { parents: :friends }``` association will be preloaded if query includes ```friends``` inside ```parents```, like: ```user(id: 10) { friends { allParents { { friends { ... } } } } }```  
-    
-    * ```add_preload 'friends|allFriends', :friends```
-      (Multiple gql queries) ```:friends``` association will be preloaded if query includes ```friends``` or ```allFriends```, like: ```user(id: 10) { friends { ... } }``` OR ```user(id: 10) { allFriends { ... } }```   
-      
-    * ```add_preload 'ignoredFriends', 'ignored_friends.user'```
-      (Deep preloading) ```{ ignored_friends: :user }``` association will be preloaded if query includes ```inogredFriends```, like: ```user(id: 10) { ignoredFriends { ... } }```   
+    `preload:` accepts:
+    - `true`: Will use field key as the association name    
+      `field :parents, ..., preload: true` will preload `parents` association
+    - `Symbol`: Custom association name    
+      `field :friends, ..., preload: :user_friends` will preload `user_friends` association
+    - `String`: Tied associations    
+      `field :excluded_friends, ..., preload: 'excluded_friends.user'` will preload `excluded_friends -> user` association
+    - `Hash`: Deep preload definitions   
+      `field :best_friends, ..., preload: { preload: :user_friends, parents: :parents }'`  
+      * Will preload `user_friends` and `user_friends.parents` only if query includes inner definition, like `user(id: 10) { bestFriends { id parents { ... } } }`       
+      * Will not preload `user_friends.parents` if query does not include inner definition, like `user(id: 10) { bestFriends { id } }`
+        
     
   * Preloads in query results
-    ```ruby
-      # queries/users.rb
-      def user(id:)
-        user = include_gql_preloads(:user, User.where(id: id))
-      end
-    ```
-    - include_gql_preloads: Will preload all preloads configured in UserType based on the gql query.
+    - BEFORE   
+      ```ruby
+        # queries/users.rb
+        def users(ids:)
+          users = User.where(id: ids)
+        end
+      ```
+      Does not apply preloads to the root query.
+    - AFTER
+      ```ruby
+        def users(ids:)
+          user = include_gql_preloads(User.where(id: id))
+        end
+      ```
+      Root query applies all defined preloads
+      
+    - `include_gql_preloads(collection, query_key: nil, type_klass: nil)`: Will include all preloads configured in `type_klass` (UserType) based on the gql query.
+      - `collection` (ActiveRecordCollection) Query results
+      - `query_key` (String | Sym, default: method name) Field result key
+      - `type_klass:` (GQL TypeClass, default: calculates using query_key)
     
   * Preloads in mutation results
     ```ruby
@@ -52,12 +54,14 @@ This gem helps you to define all nested preloads to be added when required for g
       field :users, [Types::UserType], null: true  
       def resolve(ids:)
         affected_users = User.where(id: ids)
-        affected_users = include_gql_preloads(:users, affected_users)
-        puts affected_users.first&.friends
+        affected_users = include_gql_preloads(affected_users, query_key: :users)
         { users: affected_users }
       end
     ```
-    - include_gql_preloads: Will preload all preloads configured in UserType based on the gql query.
+    - `include_gql_preloads(collection, query_key: , type_klass: nil)`: Will include all preloads configured in `type_klass` (UserType) based on the gql query.
+      - `collection` (ActiveRecordCollection) Query results
+      - `query_key` (String | Sym) Field result key 
+      - `type_klass:` (GQL TypeClass, default: calculates using query_key)
     
 ## Installation
 Add this line to your application's Gemfile:
@@ -76,6 +80,12 @@ Or install it yourself as:
 $ gem install graphql_preload_queries
 ```
 
+For debugging mode:
+```
+  # config/initializers/gql_preload.rb
+  GraphqlPreloadQueries::DEBUG = true
+```
+
 ## Contributing
 Bug reports and pull requests are welcome on GitHub at https://github.com/owen2345/graphql_preload_queries. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 

data/config/initializers/add_mutation_helper.rb

@@ -5,10 +5,11 @@ Rails.application.config.to_prepare do
   GraphQL::Schema::Mutation.class_eval do
     # TODO: auto recover type_klass using result key
     # Add corresponding preloads to mutation results
-    # @param gql_result_key (String | Sym)
+    # @param query_key (String | Sym)
     # @param collection (ActiveCollection)
     # @param type_klass (GQL TypeClass)
-    def include_gql_preloads(gql_result_key, collection, type_klass = nil)
+    def include_gql_preloads(collection, query_key:, type_klass: nil)
+      gql_result_key = GraphQL::Schema::Member::BuildType.camelize(query_key.to_s)
       type_klass ||= preload_type_klass(gql_result_key.to_s)
       klass = GraphqlPreloadQueries::Extensions::Preload
       ast_node = preload_find_node(gql_result_key)

data/config/initializers/add_preload_field.rb

@@ -22,7 +22,7 @@ Rails.application.config.to_prepare do
       #    add_preload(:allUsers, { preload: :users, 'allComments|comments' => :comments } })
       ## preload key can be omitted to use the same name as the key
       #    add_preload(:users, { 'allComments|comments' => :comments } })
-      def add_preload(key, preload)
+      def add_preload(key, preload = key)
         preload ||= key
         raise('Invalid preload query key') if [String, Symbol].exclude?(key.class)
         raise('Invalid preload preload key') if [String, Symbol, Hash].exclude?(preload.class)
@@ -31,6 +31,14 @@ Rails.application.config.to_prepare do
         key = GraphQL::Schema::Member::BuildType.camelize(key.to_s)
         preloads[key] = preload
       end
+
+      alias_method :field_old, :field
+      def field(*args, **kwargs, &block)
+        preload = kwargs.delete(:preload)
+        key = args[0]
+        add_preload(key, preload == true ? key : preload) if preload
+        field_old(*args, **kwargs, &block)
+      end
     end
   end
 end

data/config/initializers/add_query_helper.rb

@@ -3,13 +3,14 @@
 # preload resolver for queries
 Rails.application.config.to_prepare do
   Types::QueryType.class_eval do
-    # TODO: auto recover type_klass using result key
     # Add corresponding preloads to query results
     #   Note: key is automatically calculated based on method name
-    # @param gql_result_key (String | Sym)
     # @param collection (ActiveCollection)
     # @param type_klass (GQL TypeClass, default: calculates using return type)
-    def include_gql_preloads(gql_result_key, collection, type_klass = nil)
+    # @param query_key (String | Sym) Default method name
+    def include_gql_preloads(collection, query_key: nil, type_klass: nil)
+      query_key ||= caller_locations(1, 1)[0].label
+      gql_result_key = GraphQL::Schema::Member::BuildType.camelize(query_key.to_s)
       type_klass ||= preload_type_klass(gql_result_key.to_s)
       klass = GraphqlPreloadQueries::Extensions::Preload
       ast_node = preload_find_node(gql_result_key)

data/config/initializers/patch_continue_value.rb

@@ -1,20 +1,18 @@
 # frozen_string_literal: true
 
-Rails.application.config.to_prepare do
-  GraphQL::Execution::Interpreter::Runtime.class_eval do
-    alias_method :continue_value_old, :continue_value
-    # gql args: path, value, parent_type, field, is_non_null, ast_node
-    def continue_value(*args)
-      value = args[1]
-      ast_node = args[5]
-      field = args[3]
-      type_klass = field.owner
-      if !value.is_a?(ActiveRecord::Relation) || value.loaded? || !type_klass.respond_to?(:preloads)
-        return continue_value_old(*args)
-      end
+require 'graphql/execution/interpreter/runtime'
+module GraphqlPreloadQueries::PatchContinueValue # rubocop:disable Style/ClassAndModuleChildren:
+  # gql args: path, value, parent_type, field, is_non_null, ast_node
+  def continue_value(*args)
+    value = args[1]
+    ast_node = args[5]
+    field = args[3]
+    type_klass = Array(field.instance_variable_get(:@return_type_expr))[0]
+    is_active_record = value.is_a?(ActiveRecord::Relation)
+    return super if !is_active_record || value.loaded? || !type_klass.respond_to?(:preloads)
 
-      klass = GraphqlPreloadQueries::Extensions::Preload
-      klass.preload_associations(value, ast_node, type_klass)
-    end
+    klass = GraphqlPreloadQueries::Extensions::Preload
+    klass.preload_associations(value, ast_node, type_klass)
   end
 end
+GraphQL::Execution::Interpreter::Runtime.prepend GraphqlPreloadQueries::PatchContinueValue

data/graphql_preload_queries.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |spec|
   spec.description   = 'Permit to avoid N+1 queries problem when using graphql queries'
   spec.homepage      = 'https://github.com/owen2345/graphql_preload_queries'
   spec.license       = 'MIT'
-  spec.required_ruby_version = Gem::Requirement.new('>= 2.4.0')
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.0') # rubocop:disable Gemspec/RequiredRubyVersion
 
   # spec.metadata["allowed_push_host"] = ""
 

data/lib/graphql_preload_queries.rb

@@ -5,4 +5,8 @@ require 'graphql'
 require 'graphql_preload_queries/extensions/preload'
 
 module GraphqlPreloadQueries
+  DEBUG = false
+  def self.log(msg)
+    puts "***GraphqlPreloadQueries: #{msg}" if DEBUG
+  end
 end

data/lib/graphql_preload_queries/extensions/preload.rb

@@ -12,7 +12,10 @@ module GraphqlPreloadQueries
         # @param @type_klass (GqlTypeKlass)
         # @return @data with necessary preloads
         def preload_associations(value, node, type_klass)
-          apply_preloads(value, filter_preloads(node, type_klass.preloads || {}))
+          preloads = filter_preloads(node, type_klass.preloads || {})
+          log_info = { type_klass: type_klass, preloads: preloads, configured: type_klass.preloads }
+          GraphqlPreloadQueries.log("Preloading: #{log_info}")
+          apply_preloads(value, preloads)
         end
 
         private
@@ -36,12 +39,12 @@ module GraphqlPreloadQueries
           sub_node = sub_node(node, key)
           multiple_preload = preload_conf.is_a?(Hash)
           return unless sub_node
-          return add_preload_key(root, preload_conf, []) unless multiple_preload
+          return add_preload_key(root, preload_conf, {}) unless multiple_preload
 
           child_root = nested_hash
           association_name = preload_conf[:preload] || key.to_s.underscore
           filter_preloads(sub_node, preload_conf, child_root)
-          add_preload_key(root, association_name, child_root.presence || [])
+          add_preload_key(root, association_name, child_root.presence || {})
         end
 
         def sub_node(node, key)

data/lib/graphql_preload_queries/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GraphqlPreloadQueries
-  VERSION = '0.2.0'
+  VERSION = '0.4.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql_preload_queries
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - owen2345
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-02 00:00:00.000000000 Z
+date: 2021-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -120,6 +120,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - MIT-LICENSE
@@ -153,7 +154,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="