n1_loader 1.7.1 → 1.7.3

data/examples/context/service.rb

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

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

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

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

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

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

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

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

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

@@ -1,34 +0,0 @@
-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/guides/enhanced-activerecord.md

@@ -1,266 +0,0 @@
-# Enhanced ActiveRecord
-
-- Do you like `ActiveRecord` preloading?
-- How many times have you resolved your N+1 issues with `includes` or `preload`?
-- Do you know that preloading has limitations?
-
-In this guide, I'd like to share with you tips and tricks about ActiveRecord
-preloading and how you can enhance it to the next level.
-
-Let's start by describing the models.
-
-```ruby
-# The model represents users in our application.
-class User < ActiveRecord::Base
-  # Every user may have from 0 to many payments.
-  has_many :payments
-end
-
-# The model represents payments in our application.
-class Payment < ActiveRecord::Base 
-  # Every payment belongs to a user.
-  belongs_to :user
-end
-```
-
-Assuming we want to iterate over a group of users and check how many payments they have, we may do:
-
-```ruby
-# The query we want to use to fetch users from the database.
-users = User.all
-# Iteration over selected users.
-users.each do |user|
-  # Print amount of user's payments. 
-  # This query will be called for every user, bringing an N+1 issue.
-  p user.payments.count
-end
-```
-
-We can fix the N+1 issue above in a second.
-We need to add ActiveRecord's `includes` to the query that fetches users.
-
-```ruby
-# The query to fetch users with preload payments for every selected user.
-users = User.includes(:payments).all
-```
-
-Then, we can iterate over the group again without the N+1 issue.
-
-```ruby
-users.each do |user|
-  p user.payments.count
-end
-```
-
-Experienced with ActiveRecord person may notice that the iteration above still will have an N+1 issue.
-The reason is the `.count` method and its behavior.
-This issue brings us to the first tip.
-
-### Tip 1. `count` vs `size` vs `length`
-
-- `count` - always queries the database with `COUNT` query;
-- `size` - queries the database with `COUNT` only when there is no preloaded data, returns array length otherwise;
-- `length` - always returns array length, in case there is no data, load it first.
-
-_Note:_ be careful with `size` as ordering is critical.
-
-Meaning, for `user = User.first`
-
-```ruby
-# Does `COUNT` query
-user.payments.size
-# Does `SELECT` query
-user.payments.each { |payment| }
-```
-
-is different from
-
-```ruby
-# Does `SELECT` query
-user.payments.each { |payment| }
-# No query
-user.payments.size
-```
-
-You may notice that the above solution loads all payment information when the amount is only needed.
-There is a well-known solution for this case called [counter_cache](https://guides.rubyonrails.org/association_basics.html#options-for-belongs-to-counter-cache).
-
-To use that, you need to add `payments_count` field to `users` table and adjust `Payment` model.
-
-```ruby
-# Migration to add `payments_count` to `users` table.
-class AddPaymentsCountToUsers < ActiveRecord::Migration
-  def change
-    add_column :users, :payments_count, :integer, default: 0, null: false
-  end
-end
-
-# Change `belongs_to` to have `counter_cache` option.
-class Payment < ActiveRecord::Base
-  belongs_to :user, counter_cache: true
-end
-```
-
-_Note:_ avoid adding or removing payments from the database directly or through `insert_all`/`delete`/`delete_all` as
-`counter_cache` is using ActiveRecord callbacks to update the field's value.
-
-It's worth mentioning [counter_culture](https://github.com/magnusvk/counter_culture) alternative that has many features compared with the built-in `counter_cache`
-
-## Associations with arguments
-
-Now, let's assume we want to fetch the number of payments in a time frame for every user in a group.
-
-```ruby
-from = 1.months.ago
-to = Time.current
-
-# Query to fetch users.
-users = User.all
-
-users.each do |user|
-  # Print the number of payments in a time frame for every user.
-  # Database query will be triggered for every user, meaning it has an N+1 issue.
-  p user.payments.where(created_at: from...to).count
-end
-```
-
-ActiveRecord supports defining associations with arguments.
-
-```ruby
-class User < ActiveRecord::Base
-  has_many :payments, -> (from, to) { where(created_at: from...to) }
-end
-```
-
-Unfortunately, such associations are not possible to preload with `includes`.
-Gladly, there is a solution with [N1Loader](https://github.com/djezzzl/n1_loader/).
-
-```ruby
-# Install gem dependencies.
-require 'n1_loader/active_record'
-
-class User < ActiveRecord::Base
-  n1_optimized :payments_count do
-    argument :from 
-    argument :to 
-    
-    def perform(users)
-      # Fetch the payment number once for all users.
-      payments = Payment.where(user: users).where(created_at: from...to).group(:user_id).count
-      
-      users.each do |user|
-        # Assign preloaded data to every user. 
-        # Note: it doesn't use any promises.
-        fulfill(user, payments[user.id])
-      end
-    end
-  end
-end
-
-from = 1.month.ago 
-to = Time.current
-
-# Preload `payments` N1Loader "association". Doesn't query the database yet.
-users = User.includes(:payments_count).all
-
-users.each do |user|
-  # Queries the database once, meaning has no N+1 issues.
-  p user.payments_count(from, to)
-end
-```
-
-Let's look at another example. Assuming we want to fetch the last payment for every user.
-We can try to define scoped `has_one` association and use that.
-
-```ruby
-class User < ActiveRecord::Base
-  has_one :last_payment, -> { order(id: :desc) }, class_name: 'Payment'
-end
-```
-
-We can see that preloading is working.
-
-```ruby
-users = User.includes(:last_payment)
-
-users.each do |user|
-  # No N+1. Last payment was returned.
-  p user.last_payment
-end
-```
-
-At first glance, we may think everything is alright. Unfortunately, it is not.
-
-### Tip 2. Enforce `has_one` associations on the database level
-
-ActiveRecord, fetches all available payments for every user with provided order and then assigns only first payment to the association.
-First, such querying is inefficient as we load many redundant information.
-But most importantly, this association may lead to big issues. Other engineers may use it, for example,
-for `joins(:last_payment)`. Assuming that association has strict agreement on the database level that
-a user may have none or a single payment in the database. Apparently, it may not be the case, and some queries
-will return unexpected data.
-
-Described issues may be found with [DatabaseConsistency](https://github.com/djezzzl/database_consistency).
-
-Back to the task, we can solve it with [N1Loader](https://github.com/djezzzl/n1_loader) in the following way
-
-```ruby
-require 'n1_loader/active_record'
-
-class User < ActiveRecord::Base
-  n1_optimized :last_payment do |users|
-    subquery = Payment.select('MAX(id)').where(user: users)
-    payments = Payment.where(id: subquery).index_by(&:user_id)
-    
-    users.each do |user|
-      fulfill(user, payments[user.id])
-    end
-  end
-end
-
-users = User.includes(:last_payment).all
-
-users.each do |user|
-  # Queries the database once, meaning no N+1.
-  p user.last_payment
-end
-```
-
-Attentive reader could notice that in every described case, it was a requirement to explicitly list data that we want to preload for a group of users.
-Gladly, there is a simple solution! [ArLazyPreload](https://github.com/DmitryTsepelev/ar_lazy_preload) will make N+1 disappear just by enabling it.
-As soon as you need to load association for any record, it will load it once for all records that were fetched along this one.
-And it works with ActiveRecord and N1Loader perfectly!
-
-Let's look at the example.
-
-```ruby
-# Require N1Loader with ArLazyPreload integration
-require 'n1_loader/ar_lazy_preload'
-
-# Enable ArLazyPreload globally, so you don't need to care about `includes` anymore
-ArLazyPreload.config.auto_preload = true
-
-class User < ActiveRecord::Base
-  has_many :payments
-
-  n1_optimized :last_payment do |users|
-    subquery = Payment.select('MAX(id)').where(user: users)
-    payments = Payment.where(id: subquery).index_by(&:user_id)
-
-    users.each do |user|
-      fulfill(user, payments[user.id])
-    end
-  end
-end
-
-# no need to specify `includes`
-users = User.all
-
-users.each do |user|
-  p user.payments # no N+1
-  p user.last_payment # no N+1
-end
-```
-
-As you can see, there is no need to even remember about resolving N+1 when you have both [ArLazyPreload](https://github.com/DmitryTsepelev/ar_lazy_preload) and [N1Loader](https://github.com/djezzzl/n1_loader) in your pocket.
-It works great with GraphQL API too. Give it and try and share your feedback!

data/lib/n1_loader/core/name.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module N1Loader
-  # Add support of question mark names
-  module Name
-    def n1_loader_name(name)
-      to_sym = name.is_a?(Symbol)
-
-      converted = name.to_s.gsub("?", "_question_mark")
-
-      to_sym ? converted.to_sym : converted
-    end
-  end
-end

data/n1_loader.gemspec

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "lib/n1_loader/version"
-
-Gem::Specification.new do |spec|
-  spec.name          = "n1_loader"
-  spec.version       = N1Loader::VERSION
-  spec.authors       = ["Evgeniy Demin"]
-  spec.email         = ["lawliet.djez@gmail.com"]
-
-  spec.summary       = "Loader to solve N+1 issue for good."
-  spec.homepage      = "https://github.com/djezzzl/n1_loader"
-  spec.license       = "MIT"
-  spec.required_ruby_version = ">= 2.5.0"
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/djezzzl/n1_loader"
-  spec.metadata["changelog_uri"] = "https://github.com/djezzzl/n1_loader/master/CHANGELOG.md"
-  spec.metadata["funding_uri"] = "https://opencollective.com/n1_loader#support"
-
-  spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
-  end
-  spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "activerecord", ">= 5"
-  spec.add_development_dependency "ar_lazy_preload", ">= 0.6"
-  spec.add_development_dependency "db-query-matchers", "~> 0.11"
-  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"
-  spec.add_development_dependency "rubocop", "~> 1.7"
-  spec.add_development_dependency "sqlite3", "~> 1.3"
-end