graphql_preload_queries 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc56d2e745351d747e3bf8d1950761271b0bafea51732bbff4bc88af59f7cc51
-  data.tar.gz: 290fea98e4ef1b1f1d1d5ae94a07be35409b314a5c1ce7ca98b38580baffcbd0
+  metadata.gz: f78c5c6117d7157d648c6a1cdc325978bd74e0c8c068ab990be2e51817828923
+  data.tar.gz: 2228f1f4c97aa0a29aca63bac1303c425e4a12e1b128dcc9e2d858fbb5067da9
 SHA512:
-  metadata.gz: f857c894b252512962d6488bc131b19e3b91b3ea89845d644604bd93aa4503f192673b1e45ef4f2619726d02e740d0e9086eed88c3142d7f2f4ab2cd1e0137b3
-  data.tar.gz: 9a10333cf145142d5e57890da59a90f2fc4ea755a2c0e412e8269e531850b62f132e63e5fe0eb5ff064f85c70fc6d26ebea7164badd73ce4177c688b172877e8
+  metadata.gz: d75f1393282b95a5f31202aae32634b042ef8ecd9bcf6bf947e3755fbc410994547177df7f3f924cf34b4d01298ae16da39ee216665b23ccf3de3f7460ad3d80
+  data.tar.gz: 772e252ce3c527b5326b0c504f50bc897076721f7f3bc76cd2debec645da9ea8269d81aa6d8d31491ef9d4b6cb4bd5682fe652c7de505227d7391969f867d491

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+## 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

@@ -190,5 +190,8 @@ DEPENDENCIES
   rubocop-rspec
   sqlite3
 
+RUBY VERSION
+   ruby 2.6.5p114
+
 BUNDLED WITH
    2.1.4

data/README.md

@@ -15,32 +15,40 @@ This gem helps you to define all nested preloads to be added when required for g
     end
     ```
     Examples:
-    * ```add_preload :friends```
+    * ```add_preload(:friends)```   
       ```:friends``` association will be preloaded if query includes ```friends```, like: ```user(id: 10) { friends { ... } }```
     
-    * ```add_preload :allFriends, :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 }```
+    * ```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 }```
+    * ```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 } }```
+    * ```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```
+    * ```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'```
+    * ```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
       # 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
     ```
     - include_gql_preloads: Will preload all preloads configured in UserType based on the gql query.
@@ -53,7 +61,7 @@ This gem helps you to define all nested preloads to be added when required for g
       def resolve(ids:)
         affected_users = User.where(id: ids)
         affected_users = include_gql_preloads(:users, affected_users)
-        puts affected_users.first&.friends
+        puts affected_users.first&.friends # will print preloaded friends data
         { users: affected_users }
       end
     ```

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)

data/lib/graphql_preload_queries/extensions/preload.rb

@@ -36,12 +36,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.2.1'
 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.2.1
 platform: ruby
 authors:
 - owen2345
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-02 00:00:00.000000000 Z
+date: 2021-01-21 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