graphql_preload_queries 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e487e7903d2626761868cfce9a2aa368eeb8efbfa7a930eb00988b80c0ed331
-  data.tar.gz: cbdff09086c7530c1a0015c3294ed897bb21fd5621fb46a62acb452543d503db
+  metadata.gz: bc56d2e745351d747e3bf8d1950761271b0bafea51732bbff4bc88af59f7cc51
+  data.tar.gz: 290fea98e4ef1b1f1d1d5ae94a07be35409b314a5c1ce7ca98b38580baffcbd0
 SHA512:
-  metadata.gz: 2ced151a4c528db0b2bb29f5be1d8fe6aa4d316344510503682dccb1937760b92953ac1b2825e01d5397c751f618967a85bb9f518951a7127f0525f882412517
-  data.tar.gz: b8c4a168788b2288955e941e3b5a806a125de2fe52c19fdf58956fba84c30c80e3e7e6e43e79fb285e38e7dbba590616b767d4617a7ec1869ca102d8708e41cb
+  metadata.gz: f857c894b252512962d6488bc131b19e3b91b3ea89845d644604bd93aa4503f192673b1e45ef4f2619726d02e740d0e9086eed88c3142d7f2f4ab2cd1e0137b3
+  data.tar.gz: 9a10333cf145142d5e57890da59a90f2fc4ea755a2c0e412e8269e531850b62f132e63e5fe0eb5ff064f85c70fc6d26ebea7164badd73ce4177c688b172877e8

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphql_preload_queries (0.1.0)
+    graphql_preload_queries (0.2.0)
       graphql
       rails
 

data/README.md

@@ -1,77 +1,64 @@
-# 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:)
+        user = include_gql_preloads(:user, User.where(id: 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
+        { 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
+    - include_gql_preloads: Will preload all preloads configured in UserType based on the gql query.
     
-  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
-  ```
-    
-
 ## Installation
 Add this line to your application's Gemfile:
 

data/config/initializers/add_mutation_helper.rb

@@ -0,0 +1,31 @@
+# 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)
+      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)
+        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,33 @@
+# 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)
+      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,20 @@
+# 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
+
+      klass = GraphqlPreloadQueries::Extensions::Preload
+      klass.preload_associations(value, ast_node, type_klass)
+    end
+  end
+end

data/lib/graphql_preload_queries/extensions/preload.rb

@@ -5,51 +5,51 @@
 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)
+          apply_preloads(value, filter_preloads(node, type_klass.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
 
           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.2.0'
 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.2.0
 platform: ruby
 authors:
 - owen2345
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-27 00:00:00.000000000 Z
+date: 2020-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -126,9 +126,10 @@ files:
 - 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