graphql_preload_queries 0.1.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e487e7903d2626761868cfce9a2aa368eeb8efbfa7a930eb00988b80c0ed331
-  data.tar.gz: cbdff09086c7530c1a0015c3294ed897bb21fd5621fb46a62acb452543d503db
+  metadata.gz: 89226168aa382eb59c56754b96a4eaa64c51c5f06fc6fd8d831b7795d84adf0e
+  data.tar.gz: b29ec85aa619a1f7412944d6f50388f68c9b196cc5e8607bc22fd163f3a64ed1
 SHA512:
-  metadata.gz: 2ced151a4c528db0b2bb29f5be1d8fe6aa4d316344510503682dccb1937760b92953ac1b2825e01d5397c751f618967a85bb9f518951a7127f0525f882412517
-  data.tar.gz: b8c4a168788b2288955e941e3b5a806a125de2fe52c19fdf58956fba84c30c80e3e7e6e43e79fb285e38e7dbba590616b767d4617a7ec1869ca102d8708e41cb
+  metadata.gz: 42df9aacf5b59d341fc5498a61890a1ecd5c76713179c94b81696084af7d9d4f52abdd105c26a04775aa6b8199f86398841bf230127df711ffceef386752f7f9
+  data.tar.gz: cded97146bc935064f7dcaa94034deffd06adf1b6cf3c2daaacf746fb11eef542b261debd505ccb8963ec3b67f60cf7386d4829aeaa13feaed024786fa7ec04e

data/CHANGELOG.md

@@ -0,0 +1,20 @@
+## 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" }
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphql_preload_queries (0.1.0)
+    graphql_preload_queries (0.3.1)
       graphql
       rails
 
@@ -190,5 +190,8 @@ DEPENDENCIES
   rubocop-rspec
   sqlite3
 
+RUBY VERSION
+   ruby 2.6.5p114
+
 BUNDLED WITH
    2.1.4

data/README.md

@@ -1,77 +1,72 @@
-# GraphqlPreloadQueries (In progress)
-This gem helps to define all possible preloads for graphql data results and avoid the common problem "N+1 Queries". 
+# 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". 
 
 ## Usage
-  * Preloads in query results
+  * Object Type
     ```ruby
-      # queries/articles.rb
-      def articles
-        resolve_preloads(Article.all, { allComments: :comments })
-      end
+    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
+    end
     ```
-    When articles query is performed and:
-    * The query includes "allComments", then ```:comments``` will automatically be preloaded  
-    * The query does not include "allComments", then ```:comments``` is not preloaded  
+    Examples:
+    * ```add_preload(:friends)```   
+      ```:friends``` association will be preloaded if query includes ```friends```, like: ```user(id: 10) { friends { ... } }```
     
-  * Preloads in mutation results
+    * ```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 { ... } }```   
+    
+  * Preloads in query results
     ```ruby
-      # mutations/articles/approve.rb
-      def resolve
-        affected_articles = Article.where(id: [1,2,3])
-        res = resolve_preloads(affected_articles, { allComments: :comments })
-        { articles => res }
+      # queries/users.rb
+      def user(id:)
+        # includes all preloads defined in user type
+        #   Sample: user(id: 10){ friends { id } }
+        #     :friends will be preloaded inside "user" sql query    
+        user = include_gql_preloads(:user, User.where(id: id))
+        
+        # does not include user type preloads (only sub query preloads will be applied)
+        #   Sample: user(id: 10){ friends { id parents { ... } } }
+        #     Only :parents will be preloaded inside "friends" sql query
+        user = User.find(id)
       end
     ```
-    When approve mutation is performed and:
-    * The result articles query includes "allComments", then ```:comments``` will automatically be preloaded  
-    * The result articles query does not include "allComments", then ```:comments``` is not preloaded
+    - include_gql_preloads: Will preload all preloads configured in UserType based on the gql query.
     
-  * Preloads in ObjectTypes
+  * Preloads in mutation results
     ```ruby
-      # types/article_type.rb
-      module Types
-        class ArticleType < Types::BaseObject
-          preload_field :allComments, [Types::CommentType], preload: { owner: :author }, null: false
-        end
+      # mutations/users/disable.rb
+      #...
+      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 # will print preloaded friends data
+        { users: affected_users }
       end
     ```
-    When any query is retrieving an article data and:
-    * The query includes ```owner``` inside ```allComments```, then ```:author``` will automatically be preloaded inside "allComments" query  
-    * The query does not include ```owner```, then ```:author``` is not preloaded
-    This field is exactly the same as the graphql field, except that this field expects for "preload" setting which contains all configurations for preloading
-    
-  Complex preload settings    
-  ```ruby
-    # category query
-    {
-      'posts' =>
-        [:posts, # :posts preload key will be used when: { posts { id ... } }
-          {
-            'authors|allAuthors' => [:author, { # :author key will be used when: { posts { allAuthors { id ... } } } 
-              address: :address # :address key will be used when: { posts { allAuthors { address { id ... } } } }
-            }],
-            history: :versions # :versions key will be used when: { posts { history { ... } } }
-          }
-        ],
-      'disabledPosts' => ['category_disabled_posts.post', { # :category_disabled_posts.post key will be used when: { disabledPosts { ... } }
-        authors: :authors # :authors key will be used when: { disabledPosts { authors { ... } } }
-      }]
-    }
-  ```
-  * ```authors|allAuthors``` means that the preload will be added if "authors" or "allAuthors" is present in the query
-  * ```category_disabled_posts.post``` means an inner preload, sample: ```posts.preload({ category_disabled_posts: :post })```
-    
-### Important: 
-  Is needed to omit "extra" params auto provided by Graphql when using custom resolver (only in case not using params), sample:
-  ```ruby
-    # types/post_type.rb
-    preload_field :allComments, [Types::CommentType], preload: { owner: :author }, null: false
-    def allComments(_omit_gql_params) # custom method resolver that omits non used params
-      object.allComments
-    end
-  ```
+    - include_gql_preloads: Will preload all preloads configured in UserType based on the gql query.
     
-
 ## Installation
 Add this line to your application's Gemfile:
 
@@ -89,6 +84,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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# preload resolver for mutations
+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 collection (ActiveCollection)
+    # @param type_klass (GQL TypeClass)
+    def include_gql_preloads(gql_result_key, collection, type_klass = nil)
+      gql_result_key = GraphQL::Schema::Member::BuildType.camelize(gql_result_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)
+      klass.preload_associations(collection, ast_node, type_klass)
+    end
+
+    private
+
+    def preload_find_node(key)
+      main_node = context.query.document.definitions.first.selections.first
+      main_node.selections.find { |node_i| node_i.name == key.to_s }
+    end
+
+    # @param result_key: String
+    def preload_type_klass(result_key)
+      res = self.class.fields[result_key].instance_variable_get(:@return_type_expr)
+      res.is_a?(Array) ? res.first : res
+    end
+  end
+end

data/config/initializers/add_preload_field.rb

@@ -3,26 +3,34 @@
 require 'graphql_preload_queries/extensions/preload'
 
 Rails.application.config.to_prepare do
-  # Custom preload field for Object types
   Types::BaseObject.class_eval do
-    # @param key field[:key]
-    # @param type field[:type]
-    # @param settings field[:settings] ++ { preload: {} }
-    #   preload: (Hash) { allPosts: [:posts, { author: :author }] }
-    #   ==> <cat1>.preload(posts: :author) // if author and posts are in query
-    #   ==> <cat1>.preload(:posts) // if only author is in the query
-    #   ==> <cat1>.preload() // if both of them are not in the query
-    # TODO: ability to merge extensions + extras
-    def self.preload_field(key, type, settings = {})
-      klass = GraphqlPreloadQueries::Extensions::Preload
-      custom_attrs = {
-        extras: [:ast_node],
-        extensions: [klass => settings.delete(:preload)]
-      }
-      field key, type, settings.merge(custom_attrs)
+    class << self
+      def preloads
+        @preloads ||= {}
+      end
 
-      # Fix: omit non expected "extras" param auto provided by graphql
-      define_method(key) { |_omit_non_used_args| object.send(key) } unless method_defined? key
+      # @param key (Symbol|String)
+      # @param preload (Symbol|String or Symbol|String|Hash)
+      # @Sample:
+      ## key argument supports for multiple query names
+      #    add_preload('users|allUsers', :users)
+      ## preload argument indicates the association name to be preloaded
+      #    add_preload(:allUsers, :users)
+      ## preload argument supports for nested associations
+      #    add_preload(:inactiveUsers, 'inactivated_users.user')
+      ## "preload" key should be specified to indicate the association name
+      #    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 = 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)
+
+        preload[:preload] ||= key if preload.is_a?(Hash)
+        key = GraphQL::Schema::Member::BuildType.camelize(key.to_s)
+        preloads[key] = preload
+      end
     end
   end
 end

data/config/initializers/add_query_helper.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# 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)
+      gql_result_key = GraphQL::Schema::Member::BuildType.camelize(gql_result_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)
+      klass.preload_associations(collection, ast_node, type_klass)
+    end
+
+    private
+
+    # @param key: Symbol
+    def preload_find_node(key)
+      main_node = context.query.document.definitions.first
+      main_node.selections.find { |node_i| node_i.name == key.to_s }
+    end
+
+    # @param result_key: String
+    def preload_type_klass(result_key)
+      res = self.class.fields[result_key].instance_variable_get(:@return_type_expr)
+      res.is_a?(Array) ? res.first : res
+    end
+  end
+end

data/config/initializers/patch_continue_value.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+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
+end
+GraphQL::Execution::Interpreter::Runtime.prepend GraphqlPreloadQueries::PatchContinueValue

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

@@ -5,51 +5,54 @@
 module GraphqlPreloadQueries
   module Extensions
     class Preload < GraphQL::Schema::FieldExtension
-      # extension to add eager loading when a field was already processed
-      def resolve(object:, arguments:, **_rest)
-        klass = GraphqlPreloadQueries::Extensions::Preload
-        res = yield(object, arguments)
-        return res unless res
-
-        klass.resolve_preloads(res, arguments[:ast_node], (options || {}))
-      end
-
       class << self
         # Add all the corresponding preloads to the collection
-        # @param data (ActiveCollection)
-        # @return @data with preloads configured
-        # Sample: resolve_preloads(Category.all, { allPosts: :posts })
-        def resolve_preloads(data, query_node, preload_config)
-          apply_preloads(data, filter_preloads(query_node, preload_config))
+        # @param value (ActiveCollection)
+        # @param @node (GqlNode)
+        # @param @type_klass (GqlTypeKlass)
+        # @return @data with necessary preloads
+        def preload_associations(value, node, type_klass)
+          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
+
         def apply_preloads(collection, preloads)
           collection.eager_load(preloads)
         end
 
         # find all configured preloads inside a node
         def filter_preloads(node, preload_conf, root = nested_hash)
+          return root unless node
+
           preload_conf.map do |key, sub_preload_conf|
             filter_preload(node, key, sub_preload_conf, root)
           end
           root
         end
 
-        private
-
         # find preloads under a specific key
         def filter_preload(node, key, preload_conf, root)
-          sub_node = node.selections.find do |node_i|
-            key.to_s.split('|').include?(node_i.name.to_s)
-          end
-
-          multiple_preload = preload_conf.is_a?(Array)
+          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
-          filter_preloads(sub_node, preload_conf[1], child_root)
-          add_preload_key(root, preload_conf[0], child_root.presence || [])
+          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 || {})
+        end
+
+        def sub_node(node, key)
+          is_relay_node = %w[nodes edges].include?(node.selections.first.name)
+          node = node.selections.first if is_relay_node
+          node.selections.find do |node_i|
+            key.to_s.split('|').include?(node_i.name.to_s)
+          end
         end
 
         # parse nested preload key and add it to the tree

data/lib/graphql_preload_queries/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql_preload_queries
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.1
 platform: ruby
 authors:
 - owen2345
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-27 00:00:00.000000000 Z
+date: 2021-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -120,15 +120,17 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - MIT-LICENSE
 - README.md
 - Rakefile
 - bin/rails
-- config/initializers/add_mutation_resolver.rb
+- config/initializers/add_mutation_helper.rb
 - config/initializers/add_preload_field.rb
-- config/initializers/add_query_resolver.rb
+- config/initializers/add_query_helper.rb
+- config/initializers/patch_continue_value.rb
 - gemfiles/Gemfile_4
 - gemfiles/Gemfile_5
 - gemfiles/Gemfile_6

data/config/initializers/add_mutation_resolver.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-# preload resolver for mutations
-Rails.application.config.to_prepare do
-  GraphQL::Schema::Mutation.class_eval do
-    # Add corresponding preloads to mutation results
-    # @param key (sym) key of the query
-    # @param data (ActiveCollection)
-    # @param preload_config (Same as Field: field[:preload])
-    def resolve_preloads(key, data, preload_config)
-      node = find_node(key)
-      return data unless node
-
-      # relay support (TODO: add support to skip when not using relay)
-      node = node.selections.first if %w[nodes edges].include?(node.selections.first.name)
-      GraphqlPreloadQueries::Extensions::Preload.resolve_preloads(data, node, preload_config)
-    end
-
-    private
-
-    def find_node(key)
-      main_node = context.query.document.definitions.first.selections.first
-      main_node.selections.find { |node_i| node_i.name == key.to_s }
-    end
-  end
-end

data/config/initializers/add_query_resolver.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-# preload resolver for queries
-Rails.application.config.to_prepare do
-  Types::QueryType.class_eval do
-    # Add corresponding preloads to query results
-    #   Note: key is automatically calculated based on method name
-    # @param data (ActiveCollection)
-    # @param preload_config (Same as Field: field[:preload])
-    def resolve_preloads(data, preload_config)
-      node = find_node(caller[0][/`.*'/][1..-2])
-      return data unless node
-
-      # relay support (TODO: add support to skip when not using relay)
-      node = node.selections.first if %w[nodes edges].include?(node.selections.first.name)
-      GraphqlPreloadQueries::Extensions::Preload.resolve_preloads(data, node, preload_config)
-    end
-
-    private
-
-    def find_node(key)
-      main_node = context.query.document.definitions.first
-      main_node.selections.find { |node_i| node_i.name == key.to_s }
-    end
-  end
-end