n1_loader 1.4.1 → 1.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc06934b6c230d9b48dce18c7e9ee49afad4ab32d51d4550eb3e2916fe977656
-  data.tar.gz: 456575999736bba2b4b8f33ff02a4908a7705b2cc31875bca9c80f3dbeeb4125
+  metadata.gz: 3e0025899b1fbd0329159dcd2e1ddf1d28318fe76354fd2e1378b803e49a9d96
+  data.tar.gz: 2f0f222cd9298bb56e2c3a9ae8c1f6559c7ec2bec3653c5a9a2c7c172b49b7fd
 SHA512:
-  metadata.gz: 4640cffcc0fe6e03672ba46fc16e9fc29fc33d1c18b6d9e54e4c6026cd0d0b465846a60e0b75ab0dec46fd4db21ae914a0f92d3cc4623e622b4782094d6ce680
-  data.tar.gz: a010ffac1ce7604ce9434de734fa20f0e5162ff7307f6ddcafe0b9be1119a4f37d3774b7dd4beb8d36affd56e4f30830d01904406ce1f2b2fc2989d7f9910fa1
+  metadata.gz: 48a55dd01386410a58a5fbf8ea9d556ac6fa2db33411a469b2c9f3fc99b9ccec2ad36eb482e0adba39a84af4ffd4adba6a51a8db23eba7869c03aca51add1d39
+  data.tar.gz: b4c275204251a8e6908e34af67beacd6bbc05a1fcd1168350ab538ecf48362c840c671d1223dfd3659b2fe87f1428ee0e012144c3c52fa11451a595a0b5a11d9

data/.gitignore

@@ -8,4 +8,5 @@
 /tmp/
 /.idea
 .rspec_status
-Gemfile.lock
+Gemfile.lock
+.ruby-version

data/.rubocop.yml

@@ -1,5 +1,7 @@
 AllCops:
   TargetRubyVersion: 2.5
+  Exclude:
+    - examples/**/*
 
 Style/StringLiterals:
   Enabled: true

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [1.4.4] - 2022/04/29
+
+- Inject `N1Loader::Loadable` to `ActiveRecord::Base` automatically
+- Make `reload` to call `n1_clear_cache`
+
+## [1.4.3] - 2022-04-13
+
+- Add `default` support to arguments
+
+## [1.4.2] - 2022-03-01
+
+- Add n1_clear_cache method which is useful for cases like reload in ActiveRecord
+
 ## [1.4.1] - 2022-02-24
 
 - Fix preloading of invalid objects

data/README.md

@@ -3,295 +3,147 @@
 [![CircleCI][1]][2]
 [![Gem Version][3]][4]
 
-Are you tired of fixing [N+1 issues][7]? Does it feel unnatural to you to fix it case by case in places where you need the data?
-We have a solution for you! 
+N1Loader is designed to provide a way for avoiding [N+1 issues][7] of any kind. 
+For example, it can help with resolving N+1 for:
+- database querying (most common case)
+- 3rd party service calls
+- complex calculations
+- and many more
 
-[N1Loader][8] is designed to solve the issue for good!
+> [Toptal](https://www.toptal.com#snag-only-shrewd-web-development-experts) is hiring! [Join](https://www.toptal.com#snag-only-shrewd-web-development-experts) as Freelancer or [write me](mailto:lawliet.djez@gmail.com) if you want to join Core team.
 
-It has many benefits:
-- it can be [isolated](#isolated-loaders)
-- it loads data [lazily](#lazy-loading)
-- it supports [shareable loaders](#shareable-loaders) between multiple classes
-- it supports [reloading](#reloading)
-- it supports optimized [single object loading](#optimized-single-case)
-- it supports [arguments](#arguments)
-- it has an integration with [ActiveRecord][5] which makes it brilliant ([example](#activerecord))
-- it has an integration with [ArLazyPreload][6] which makes it excellent ([example](#arlazypreload))
+## Killer feature for GraphQL API
 
-... and even more features to come! Stay tuned!
+N1Loader in combination with [ArLazyPreload][6] is a killer feature for your GraphQL API. 
+Give it a try now and see incredible results instantly! Check out the [example](examples/graphql.rb) and start benefiting from it in your projects!
 
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'n1_loader'
-```
-
-You can add integration with [ActiveRecord][5] by:
-```ruby
-gem 'n1_loader', require: 'n1_loader/active_record'
-```
-
-You can add the integration with [ActiveRecord][5] and [ArLazyPreload][6] by:
 ```ruby
 gem 'n1_loader', require: 'n1_loader/ar_lazy_preload'
 ```
 
-## Usage
-
-```ruby
-class User
-  include N1Loader::Loadable
-
-  # with inline loader
-  n1_optimized :orders_count do |users|
-    orders_per_user = Order.where(user: users).group(:user_id).count
-    
-    users.each { |user| fulfill(user, orders_per_user[user.id]) }
-  end
-end
+## Enhance [ActiveRecord][5]
 
-# For single object
-user = User.new
-user.orders_count 
+Are you working with well-known Rails application? Try it out how well N1Loader fulfills missing gaps!
 
-# For multiple objects without N+1
-users = [User.new, User.new]
-N1Loader::Preloader.new(users).preload(:orders_count)
-users.map(&:orders_count)
+```ruby
+gem 'n1_loader', require: 'n1_loader/active_record'
 ```
 
-### Lazy loading
+Are you ready to forget about N+1 once and for all? Install [ArLazyPreload][6] and see dreams come true!
 
 ```ruby
-class User
-  include N1Loader::Loadable
-
-  # with inline loader
-  n1_optimized :orders_count do |users|
-    orders_per_user = Order.where(user: users).group(:user_id).count
-
-    users.each { |user| fulfill(user, orders_per_user[user.id]) }
-  end
-end
-
-user = User.new # => nothing was done for loading
-user.orders_count # => first time loading
-
-users = [User.new, User.new] # => nothing was done for loading
-N1Loader::Preloader.new([users]).preload(:orders_count) # => we only initialized loader but didn't perform it yet
-users.map(&:orders_count) # => loading has happen for the first time (without N+1)
+gem 'n1_loader', require: 'n1_loader/ar_lazy_preload'
 ```
 
+## Standalone mode
 
-### Shareable loaders
+Are you not working with [ActiveRecord][5]? N1Loader is ready to be used as standalone solution! ([full snippet](examples/core.rb))
 
 ```ruby
-class OrdersCountLoader < N1Loader::Loader
-  def perform(users)
-    orders_per_user = Order.where(user: users).group(:user_id).count
-
-    users.each { |user| fulfill(user, orders_per_user[user.id]) }
-  end
-end
-
-class User
-  include N1Loader::Loadable
-
-  n1_optimized :orders_count, OrdersCountLoader
-end
-
-class Customer
-  include N1Loader::Loadable
-
-  n1_optimized :orders_count, OrdersCountLoader
-end
-
-User.new.orders_count # => works
-Customer.new.orders_count  # => works
+gem 'n1_loader'
 ```
 
-### Reloading
-
-```ruby
-class User
-  include N1Loader::Loadable
-
-  # with inline loader
-  n1_optimized :orders_count do |users|
-    orders_per_user = Order.where(user: users).group(:user_id).count
-
-    users.each { |user| fulfill(user, orders_per_user[user.id]) }
-  end
-end
-
-user = User.new
-user.orders_count # => loader is executed first time and value was cached
-user.orders_count(reload: true) # => loader is executed again and a new value was cached
+## How to use it?
 
-users = [User.new, User.new]
-N1Loader::Preloader.new(users).preload(:orders_count) # => loader was initialized but not yet executed
-users.map(&:orders_count) # => loader was executed first time without N+1 issue and values were cached
-
-N1Loader::Preloader.new(users).preload(:orders_count) # => loader was initialized again but not yet executed
-users.map(&:orders_count) # => new loader was executed first time without N+1 issue and new values were cached
-```
+N1Loader provides DSL that allows you to define N+1 ready loaders that can 
+be injected into your objects in a way that you can avoid N+1 issues.
 
-### Isolated loaders
+> _Disclaimer_: examples below are working but designed to show N1Loader potentials only.
+In real live applications, N1Loader can be applied anywhere and in more [elegant way](examples/isolated_loader.rb).  
 
+Let's look at simple example below ([full snippet](examples/active_record_integration.rb)):
 ```ruby
-class IsolatedLoader < N1Loader::Loader
-  def perform(elements)
-    elements.each { |element| fulfill(element, [element]) }
+class User < ActiveRecord::Base
+  has_many :payments
+
+  n1_optimized :payments_total do |users|
+    total_per_user = 
+      Payment.group(:user_id)
+        .where(user: users)
+        .sum(:amount)
+        .tap { |h| h.default = 0 }
+
+    users.each do |user|
+      total = total_per_user[user.id]
+      fulfill(user, total)
+    end
   end
 end
 
-objects = [1, 2, 3, 4]
-loader = IsolatedLoader.new(objects)
-objects.each do |object|
-  loader.for(object) # => it has no N+1 and it doesn't require to be injected in the class
+class Payment < ActiveRecord::Base
+  belongs_to :user
+
+  validates :amount, presence: true
 end
-```
 
-### Optimized single case
+# A user has many payments. 
+# Assuming, we want to know for group of users, what is a total of their payments, we can do the following:
 
-```ruby
-class User
-  include N1Loader::Loadable
+# Has N+1 issue
+p User.all.map { |user| user.payments.sum(&:amount) }
 
-  n1_optimized :orders_count do # no arguments passed to the block, so we can override both perform and single.
-    def perform(users)
-      orders_per_user = Order.where(user: users).group(:user_id).count
-
-      users.each { |user| fulfill(user, orders_per_user[user.id]) }
-    end
-    
-    # Optimized for single object loading
-    def single(user)
-      user.orders.count
-    end
-  end
-end
+# Has no N+1 but we load too many data that we don't actually need
+p User.all.includes(:payments).map { |user| user.payments.sum(&:amount) }
 
-user = User.new
-user.orders_count # single will be used here
-
-users = [User.new, User.new]
-N1Loader::Preloader.new(users).preload(:orders_count)
-users.map(&:orders_count) # perform will be used once without N+1
+# Has no N+1 and we load only what we need
+p User.all.includes(:payments_total).map { |user| user.payments_total }
 ```
 
-### Arguments
+Let's assume now, that we want to calculate the total of payments for the given period for a group of users. 
+N1Loader can do that as well! ([full snippet](examples/arguments_support.rb)) 
 
 ```ruby
-class User
-  include N1Loader::Loadable
-
-  n1_optimized :orders_count do 
-    argument :type 
-    
-    def perform(users)
-      orders_per_user = Order.where(type: type, user: users).group(:user_id).count
-      
-      users.each { |user| fulfill(user, orders_per_user[user.id]) }
-    end
-  end
-end
-
-user = User.new
-user.orders_count(type: :gifts) # The loader will be performed first time for this argument
-user.orders_count(type: :sales) # The loader will be performed first time for this argument
-user.orders_count(type: :gifts) # The cached value will be used
-
-users = [User.new, User.new]
-N1Loader::Preloader.new(users).preload(:orders_count)
-users.map { |user| user.orders_count(type: :gifts) } # No N+1 here
-```
+class User < ActiveRecord::Base
+  has_many :payments
 
-_Note_: By default, we use `arguments.map(&:object_id)` to identify arguments but in some cases, 
-you may want to override it, for example:
+  n1_optimized :payments_total do
+    argument :from
+    argument :to
 
-```ruby
-class User
-  include N1Loader::Loadable
-
-  n1_optimized :orders_count do
-    argument :sale 
-    
-    cache_key { sale.id }
-    
     def perform(users)
-      orders_per_user = Order.where(sale: sale, user: users).group(:user_id).count
-      
-      users.each { |user| fulfill(user, orders_per_user[user.id]) }
+      total_per_user =
+        Payment
+          .group(:user_id)
+          .where(created_at: from..to)
+          .where(user: users)
+          .sum(:amount)
+          .tap { |h| h.default = 0 }
+
+      users.each do |user|
+        total = total_per_user[user.id]
+        fulfill(user, total)
+      end
     end
   end
 end
 
-user = User.new
-user.orders_count(sale: Sale.first) # perform will be executed and value will be cached
-user.orders_count(sale: Sale.first) # the cached value will be returned
-```
-
-
-## Integrations
-
-### [ActiveRecord][5]
-
-_Note_: Rails 7 support is coming soon! Stay tuned!
+class Payment < ActiveRecord::Base
+  belongs_to :user
 
-```ruby
-class User < ActiveRecord::Base
-  include N1Loader::Loadable
-
-  n1_optimized :orders_count do |users|
-    orders_per_user = Order.where(user: users).group(:user_id).count
-
-    users.each { |user| fulfill(user, orders_per_user[user.id]) }
-  end
+  validates :amount, presence: true
 end
 
-# For single user
-user = User.first
-user.orders_count 
+# Has N+1
+p User.all.map { |user| user.payments.select { |payment| payment.created_at >= from && payment.created_at <= to }.sum(&:amount) }
 
-# For many users without N+1
-User.limit(5).includes(:orders_count).map(&:orders_count)
+# Has no N+1 but we load too many data that we don't need
+p User.all.includes(:payments).map { |user| user.payments.select { |payment| payment.created_at >= from && payment.created_at <= to }.sum(&:amount) }
 
-# or with explicit preloader
-users = User.limit(5).to_a
-N1Loader::Preloader.new(users).preload(:orders_count)
-
-# No N+1 here
-users.map(&:orders_count)
+# Has no N+1 and calculation is the most efficient
+p User.all.includes(:payments_total).map { |user| user.payments_total(from: from, to: to) }
 ```
 
-### [ArLazyPreload][6]
-
-```ruby
-class User < ActiveRecord::Base
-  include N1Loader::Loadable
-
-  n1_optimized :orders_count do |users|
-    orders_per_user = Order.where(user: users).group(:user_id).count
-
-    users.each { |user| fulfill(user, orders_per_user[user.id]) }
-  end
-end
-
-# For single user
-user = User.first
-user.orders_count
-
-# For many users without N+1
-User.lazy_preload(:orders_count).all.map(&:orders_count)
-# or 
-User.preload_associations_lazily.all.map(&:orders_count)
-# or 
-ArLazyPreload.config.auto_preload = true
-User.all.map(:orders_count)
-```
+## Features and benefits
+
+- N1Loader doesn't use Promises which means it's easy to debug
+- Doesn't require injection to objects, can be used in [isolation](examples/isolated_loader.rb)
+- Loads data [lazily](examples/lazy_loading.rb)
+- Loaders can be [shared](examples/shared_loader.rb) between multiple classes
+- Loaded data can be [re-fetched](examples/reloading.rb)
+- Loader can be optimized for [single cases](examples/single_case.rb)
+- Loader support [arguments](examples/arguments_support.rb)
+- Has [integration](examples/active_record_integration.rb) with [ActiveRecord][5] which makes it brilliant
+- Has [integration](examples/ar_lazy_integration.rb) with [ArLazyPreload][6] which makes it excellent
 
 ## Contributing
 

data/examples/active_record_integration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "n1_loader/active_record"
+
+require_relative 'context/setup_database'
+
+class User < ActiveRecord::Base
+  has_many :payments
+
+  n1_optimized :payments_total do |users|
+    total_per_user = Payment.group(:user_id).where(user: users).sum(:amount).tap { |h| h.default = 0 }
+
+    users.each do |user|
+      total = total_per_user[user.id]
+      fulfill(user, total)
+    end
+  end
+end
+
+class Payment < ActiveRecord::Base
+  belongs_to :user
+
+  validates :amount, presence: true
+end
+
+fill_database
+
+# Has N+1
+p User.all.map { |user| user.payments.sum(&:amount) }
+# Has no N+1 but we load too many data that we don't need
+p User.all.includes(:payments).map { |user| user.payments.sum(&:amount) }
+# Has no N+1 and calculation is the most efficient
+p User.all.includes(:payments_total).map(&:payments_total)

data/examples/ar_lazy_integration.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "n1_loader/ar_lazy_preload"
+
+require_relative 'context/setup_ar_lazy'
+require_relative 'context/setup_database'
+
+class User < ActiveRecord::Base
+  has_many :payments
+
+  n1_optimized :payments_total do |users|
+    total_per_user = Payment.group(:user_id).where(user: users).sum(:amount).tap { |h| h.default = 0 }
+
+    users.each do |user|
+      total = total_per_user[user.id]
+      fulfill(user, total)
+    end
+  end
+end
+
+class Payment < ActiveRecord::Base
+  belongs_to :user
+
+  validates :amount, presence: true
+end
+
+fill_database
+
+# Has N+1
+p User.all.map { |user| user.payments.sum(&:amount) }
+
+# Has no N+1 but we load too many data that we don't need
+p User.preload_associations_lazily.map(&:payments_total)
+
+# Has no N+1 and calculation is the most efficient
+ArLazyPreload.config.auto_preload = true
+User.all.map(&:payments_total)

data/examples/arguments_support.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "n1_loader/active_record"
+
+require_relative 'context/setup_database'
+
+class User < ActiveRecord::Base
+  has_many :payments
+
+  n1_optimized :payments_total do
+    # Arguments can be:
+    # argument :something, optional: true
+    # argument :something, default: -> { 100 }
+    #
+    # Note: do not use mutable (mostly timing related) defaults like:
+    # argument :from, default -> { 2.minutes.from_now }
+    # because such values will be unique for every loader call which will make N+1 issue stay
+    argument :from
+    argument :to
+
+    # This is used to define logic how loaders are compared to each other
+    # default is:
+    # cache_key { *arguments.map(&:object_id) }
+    cache_key { [from, to] }
+
+    def perform(users)
+      total_per_user =
+        Payment
+        .group(:user_id)
+        .where(created_at: from..to)
+        .where(user: users)
+        .sum(:amount)
+        .tap { |h| h.default = 0 }
+
+      users.each do |user|
+        total = total_per_user[user.id]
+        fulfill(user, total)
+      end
+    end
+  end
+end
+
+class Payment < ActiveRecord::Base
+  belongs_to :user
+
+  validates :amount, presence: true
+end
+
+fill_database
+
+from = 2.days.ago
+to = 1.day.ago
+
+# Has N+1
+p User.all.map { |user|
+  user.payments.select do |payment|
+    payment.created_at >= from && payment.created_at <= to
+  end.sum(&:amount)
+}
+# Has no N+1 but we load too many data that we don't need
+p User.all.includes(:payments).map { |user|
+  user.payments.select do |payment|
+    payment.created_at >= from && payment.created_at <= to
+  end.sum(&:amount)
+}
+# Has no N+1 and calculation is the most efficient
+p User.all.includes(:payments_total).map { |user| user.payments_total(from: from, to: to) }

data/examples/context/service.rb

@@ -0,0 +1,20 @@
+# 3rd party service, or database, or anything else that can perform in batches
+class Service
+  def self.count
+    @count ||= 0
+  end
+
+  def self.increase!
+    @count = (@count || 0) + 1
+  end
+
+  def self.receive(*users)
+    increase!
+
+    users.flatten.map(&:object_id)
+  end
+
+  def self.single(user)
+    user.object_id
+  end
+end

data/examples/context/setup_ar_lazy.rb

@@ -0,0 +1,15 @@
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Base.include(ArLazyPreload::Base)
+
+  ActiveRecord::Relation.prepend(ArLazyPreload::Relation)
+  ActiveRecord::AssociationRelation.prepend(ArLazyPreload::AssociationRelation)
+  ActiveRecord::Relation::Merger.prepend(ArLazyPreload::Merger)
+
+  [
+    ActiveRecord::Associations::CollectionAssociation,
+    ActiveRecord::Associations::Association
+  ].each { |klass| klass.prepend(ArLazyPreload::Association) }
+
+  ActiveRecord::Associations::CollectionAssociation.prepend(ArLazyPreload::CollectionAssociation)
+  ActiveRecord::Associations::CollectionProxy.prepend(ArLazyPreload::CollectionProxy)
+end

data/examples/context/setup_database.rb

@@ -0,0 +1,26 @@
+require "sqlite3"
+
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+ActiveRecord::Base.connection.tables.each do |table|
+  ActiveRecord::Base.connection.drop_table(table, force: :cascade)
+end
+ActiveRecord::Schema.verbose = false
+ActiveRecord::Base.logger = Logger.new($stdout)
+
+ActiveRecord::Schema.define(version: 1) do
+  create_table(:payments) do |t|
+    t.belongs_to :user
+    t.integer :amount
+    t.timestamps
+  end
+  create_table(:users)
+end
+
+def fill_database
+  10.times do
+    user = User.create!
+    10.times do
+      Payment.create!(user: user, amount: rand(1000))
+    end
+  end
+end

data/examples/core.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "n1_loader"
+
+require_relative 'context/service'
+
+# Class that wants to request 3rd party service without N+1
+class User
+  include N1Loader::Loadable
+
+  def unoptimized_call
+    Service.receive(self)[0]
+  end
+
+  n1_optimized :optimized_call do |users|
+    data = Service.receive(users)
+
+    users.each_with_index do |user, index|
+      fulfill(user, data[index])
+    end
+  end
+end
+
+# works fine for single case
+user = User.new
+p "Works correctly: #{user.unoptimized_call == user.optimized_call}"
+
+users = [User.new, User.new]
+
+# Has N+1
+count_before = Service.count
+p users.map(&:unoptimized_call)
+p "Has N+1 #{Service.count == count_before + users.count}"
+
+# Has no N+1
+count_before = Service.count
+N1Loader::Preloader.new(users).preload(:optimized_call)
+p users.map(&:optimized_call)
+p "Has no N+1: #{Service.count == count_before + 1}"

data/examples/graphql.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "n1_loader/ar_lazy_preload"
+require 'graphql'
+
+require_relative 'context/setup_database'
+require_relative 'context/setup_ar_lazy'
+
+class User < ActiveRecord::Base
+  has_many :payments
+
+  n1_optimized :payments_total do |users|
+    total_per_user = Payment.group(:user_id).where(user: users).sum(:amount).tap { |h| h.default = 0 }
+
+    users.each do |user|
+      total = total_per_user[user.id]
+      fulfill(user, total)
+    end
+  end
+end
+
+class Payment < ActiveRecord::Base
+  belongs_to :user
+
+  validates :amount, presence: true
+end
+
+10.times do
+  user = User.create!
+  10.times do
+    Payment.create!(user: user, amount: rand(1000))
+  end
+end
+
+ArLazyPreload.config.auto_preload = true
+# Or use +preload_associations_lazily+ when loading objects from database
+
+class UserType < GraphQL::Schema::Object
+  field :payments_total, Integer
+end
+
+class QueryType < GraphQL::Schema::Object
+  field  :users, [UserType]
+
+  def users
+    User.all
+  end
+end
+
+class Schema < GraphQL::Schema
+  query QueryType
+end
+
+query_string = <<~GQL
+  {
+    users {
+      paymentsTotal
+    }
+  }
+GQL
+
+# No N+1. And never will be!
+p Schema.execute(query_string)['data']

data/examples/isolated_loader.rb

@@ -0,0 +1,13 @@
+require 'n1_loader'
+
+class IsolatedLoader < N1Loader::Loader
+  def perform(elements)
+    elements.each { |element| fulfill(element, [element]) }
+  end
+end
+
+objects = [1, 2, 3, 4]
+loader = IsolatedLoader.new(objects)
+objects.each do |object|
+  loader.for(object) # => it has no N+1 and it doesn't require to be injected in the class
+end

data/examples/lazy_loading.rb

@@ -0,0 +1,26 @@
+require 'n1_loader'
+
+require_relative 'context/service'
+
+# Class that wants to request 3rd party service without N+1
+class User
+  include N1Loader::Loadable
+
+  n1_optimized :optimized_call do |users|
+    data = Service.receive(users)
+
+    users.each_with_index do |user, index|
+      fulfill(user, data[index])
+    end
+  end
+end
+
+users = [User.new, User.new, User.new]
+
+# Initialized loader but didn't perform it yet
+N1Loader::Preloader.new(users).preload(:optimized_call)
+p "No calls yet: #{Service.count == 0}"
+
+# First time loading
+users.map(&:optimized_call)
+p "First time loaded: #{Service.count == 1}"

data/examples/reloading.rb

@@ -0,0 +1,32 @@
+require 'n1_loader'
+
+require_relative 'context/service'
+
+class User
+  include N1Loader::Loadable
+
+  n1_optimized :optimized_call do |users|
+    data = Service.receive(users)
+
+    users.each_with_index do |user, index|
+      fulfill(user, data[index])
+    end
+  end
+end
+
+users = [User.new, User.new, User.new]
+
+# Initialized loader but didn't perform it yet
+N1Loader::Preloader.new(users).preload(:optimized_call)
+p "No calls yet: #{Service.count == 0}"
+
+# First time loading
+users.map(&:optimized_call)
+p "First time loaded: #{Service.count == 1}"
+
+users.first.optimized_call(reload: true)
+p "Reloaded for this object only: #{Service.count == 2}"
+
+users.first.n1_clear_cache
+users.first.optimized_call
+p "Reloaded for this object only: #{Service.count == 3}"

data/examples/shared_loader.rb

@@ -0,0 +1,34 @@
+require 'n1_loader'
+
+require_relative 'context/service'
+
+# Loader that will be shared between multiple classes
+class SharedLoader < N1Loader::Loader
+  def perform(objects)
+    data = Service.receive(objects)
+
+    objects.each_with_index do |user, index|
+      fulfill(user, data[index])
+    end
+  end
+end
+
+class User
+  include N1Loader::Loadable
+
+  n1_optimized :optimized_call, SharedLoader
+end
+
+class Payment
+  include N1Loader::Loadable
+
+  n1_optimized :optimized_call, SharedLoader
+end
+
+objects = [User.new, Payment.new, User.new, Payment.new]
+
+N1Loader::Preloader.new(objects).preload(:optimized_call)
+
+# First time loading for all objects
+objects.map(&:optimized_call)
+p "Loaded for all once: #{Service.count == 1}"

data/examples/single_case.rb

@@ -0,0 +1,34 @@
+require 'n1_loader'
+
+require_relative 'context/service'
+
+# Loader that will be shared between multiple classes
+class OptimizedLoader < N1Loader::Loader
+  def perform(objects)
+    data = Service.receive(objects)
+
+    objects.each_with_index do |user, index|
+      fulfill(user, data[index])
+    end
+  end
+
+  def single(object)
+    Service.single(object)
+  end
+end
+
+class User
+  include N1Loader::Loadable
+
+  n1_optimized :optimized_call, OptimizedLoader
+end
+
+objects = [User.new, User.new]
+
+N1Loader::Preloader.new(objects).preload(:optimized_call)
+
+objects.map(&:optimized_call)
+p "Used multi-case perform: #{Service.count == 1}"
+
+User.new.optimized_call
+p "Used single-case perform: #{Service.count == 1}"

data/lib/n1_loader/active_record/base.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module N1Loader
+  module ActiveRecord
+    # Extension module for ActiveRecord::Base
+    module Base
+      extend ActiveSupport::Concern
+
+      include N1Loader::Loadable
+
+      # Clear N1Loader cache on reloading the object
+      def reload(*)
+        n1_clear_cache
+        super
+      end
+    end
+  end
+end

data/lib/n1_loader/active_record.rb

@@ -16,6 +16,7 @@ end
 ActiveSupport.on_load(:active_record) do
   require_relative "active_record/loader"
   require_relative "active_record/loader_collection"
+  require_relative "active_record/base"
 
   case ActiveRecord::VERSION::MAJOR
   when 6
@@ -25,4 +26,5 @@ ActiveSupport.on_load(:active_record) do
   end
 
   ActiveRecord::Associations::Preloader.prepend(N1Loader::ActiveRecord::Associations::Preloader)
+  ActiveRecord::Base.include(N1Loader::ActiveRecord::Base)
 end

data/lib/n1_loader/core/loadable.rb

@@ -32,6 +32,12 @@ module N1Loader
       send("#{name}_loader=", loader_collection)
     end
 
+    def n1_clear_cache
+      self.class.n1_loaders.each do |name|
+        n1_loader_set(name, nil)
+      end
+    end
+
     def self.included(base)
       base.extend(ClassMethods)
     end
@@ -45,6 +51,10 @@ module N1Loader
         respond_to?("#{name}_loader")
       end
 
+      def n1_loaders
+        @n1_loaders ||= superclass.respond_to?(:n1_loaders) ? superclass.n1_loaders.dup : []
+      end
+
       def n1_optimized(name, loader = nil, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
         loader ||= Class.new(N1Loader::Loader) do
           if block.arity == 1
@@ -56,6 +66,8 @@ module N1Loader
         loader_name = "#{name}_loader"
         loader_variable_name = "@#{loader_name}"
 
+        n1_loaders << name
+
         define_singleton_method(loader_name) do
           loader
         end

data/lib/n1_loader/core/loader.rb

@@ -17,10 +17,13 @@ module N1Loader
       # @param name [Symbol]
       # @param opts [Hash]
       # @option opts [Boolean] optional false by default
+      # @option opts [Proc] default
       def argument(name, **opts)
+        opts[:optional] = true if opts[:default]
+
         @arguments ||= []
 
-        define_method(name) { args[name] }
+        define_method(name) { args[name] ||= opts[:default]&.call }
 
         @arguments << opts.merge(name: name)
       end

data/lib/n1_loader/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module N1Loader
-  VERSION = "1.4.1"
+  VERSION = "1.4.4"
 end

data/n1_loader.gemspec

@@ -22,9 +22,10 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "activerecord", ">= 5"
+  spec.add_development_dependency "activerecord", ">= 5", "< 7"
   spec.add_development_dependency "ar_lazy_preload", ">= 0.6"
   spec.add_development_dependency "db-query-matchers", "~> 0.10"
+  spec.add_development_dependency "graphql", "~> 2.0"
   spec.add_development_dependency "rails", ">= 5"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rspec_junit_formatter", "~> 0.4"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: n1_loader
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.4.4
 platform: ruby
 authors:
 - Evgeniy Demin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-24 00:00:00.000000000 Z
+date: 2022-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -17,6 +17,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -24,6 +27,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
 - !ruby/object:Gem::Dependency
   name: ar_lazy_preload
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +58,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -145,10 +165,24 @@ files:
 - ar_lazy_preload-gemfiles/ar_lazy_preload_master.gemfile
 - bin/console
 - bin/setup
+- examples/active_record_integration.rb
+- examples/ar_lazy_integration.rb
+- examples/arguments_support.rb
+- examples/context/service.rb
+- examples/context/setup_ar_lazy.rb
+- examples/context/setup_database.rb
+- examples/core.rb
+- examples/graphql.rb
+- examples/isolated_loader.rb
+- examples/lazy_loading.rb
+- examples/reloading.rb
+- examples/shared_loader.rb
+- examples/single_case.rb
 - lib/n1_loader.rb
 - lib/n1_loader/active_record.rb
 - lib/n1_loader/active_record/associations_preloader_v5.rb
 - lib/n1_loader/active_record/associations_preloader_v6.rb
+- lib/n1_loader/active_record/base.rb
 - lib/n1_loader/active_record/loader.rb
 - lib/n1_loader/active_record/loader_collection.rb
 - lib/n1_loader/ar_lazy_preload.rb
@@ -186,7 +220,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Loader to solve N+1 issue for good.