batch-loader 0.3.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e17f7617e248aa7b911c64dac882cdb192bb9b2c
-  data.tar.gz: 6b9d612ae58f95a0715c0d23427176375d8450c4
+  metadata.gz: 76a4b89eafc3e0421ef17d5b4fc8147e56058307
+  data.tar.gz: d146eea3db7f1e5fe2656484ab56dbf135a44333
 SHA512:
-  metadata.gz: b34fa00da8e309c99b7bae84e8155dcd847722f5da30d60c19a318a114459d825645ef3377259219e5fa9c64c1ffd1495e4ac78bf4907ab811f66b8a8b0ba178
-  data.tar.gz: 7e97b3aa40becb1515a3a26d2a1992f2ccbfda2a4f5f090fc7c329e898319aa765edec379f8a0070d555276a0ab00cb24d9cf4235b230d0e7fcb6a0e0bce6625
+  metadata.gz: b110668f7022e179dace6e64200a05dada22ad8cb0064a50b5dcfaf960e5ae8884ca1fb6d9b8e8b2fb84cd16e15637633c7dfaa7c69d1f82bca74be2bddab11e
+  data.tar.gz: 46f3e19c98b9adebe2bb24c6bfaf59a25566da8b735317ac6b671721867394f4a193e5faceab7b8b7c4d8bee10db26dbfcf51a85dfade8133bda474ab17b9f39

data/CHANGELOG.md

@@ -8,10 +8,50 @@ one of the following labels: `Added`, `Changed`, `Deprecated`,
 to manage the versions of this gem so
 that you can set version constraints properly.
 
-#### [Unreleased](https://github.com/exAspArk/batch-loader/compare/v0.3.0...HEAD)
+#### [Unreleased](https://github.com/exAspArk/batch-loader/compare/v1.0.0...HEAD)
 
 * WIP
 
+#### [v1.0.0](https://github.com/exAspArk/batch-loader/compare/v0.3.0...v1.0.0) – 2017-08-21
+
+* `Removed`: `BatchLoader.sync!` and `BatchLoader#sync`. Now syncing is done implicitly when you call any method on the lazy object.
+
+Before:
+
+```ruby
+def load_user(user_id)
+  BatchLoader.for(user_id).batch { ... }
+end
+
+users = [load_user(1), load_user(2), load_user(3)]
+puts BatchLoader.sync!(users) # or users.map!(&:sync)
+```
+
+After:
+
+```ruby
+users = [load_user(1), load_user(2), load_user(3)]
+puts users
+```
+
+* `Removed`: `BatchLoader#load`. Use `loader` lambda instead:
+
+Before:
+
+```ruby
+BatchLoader.for(user_id).batch do |user_ids, batch_loader|
+  user_ids.each { |user_id| batch_loader.load(user_id, user_id) }
+end
+```
+
+After:
+
+```ruby
+BatchLoader.for(user_id).batch do |user_ids, loader|
+  user_ids.each { |user_id| loader.call(user_id, user_id) }
+end
+```
+
 #### [v0.3.0](https://github.com/exAspArk/batch-loader/compare/v0.2.0...v0.3.0) – 2017-08-03
 
 * `Added`: `BatchLoader::Executor.clear_current` to clear cache manually.

data/README.md

@@ -6,7 +6,7 @@
 [![Downloads](https://img.shields.io/gem/dt/batch-loader.svg)](https://rubygems.org/gems/batch-loader)
 [![Latest Version](https://img.shields.io/gem/v/batch-loader.svg)](https://rubygems.org/gems/batch-loader)
 
-Simple tool to avoid N+1 DB queries, HTTP requests, etc.
+This gem provides a generic lazy batching mechanism to avoid N+1 DB queries, HTTP queries, etc.
 
 ## Contents
 
@@ -15,26 +15,30 @@ Simple tool to avoid N+1 DB queries, HTTP requests, etc.
   * [Why?](#why)
   * [Basic example](#basic-example)
   * [How it works](#how-it-works)
-  * [REST API example](#rest-api-example)
+  * [RESTful API example](#restful-api-example)
   * [GraphQL example](#graphql-example)
   * [Caching](#caching)
 * [Installation](#installation)
 * [Implementation details](#implementation-details)
 * [Development](#development)
 * [Contributing](#contributing)
+* [Alternatives](#alternatives)
 * [License](#license)
 * [Code of Conduct](#code-of-conduct)
 
+<a href="https://www.universe.com/" target="_blank" rel="noopener noreferrer">
+  <img src="images/universe.png" height="41" width="153" alt="Sponsored by Universe" style="max-width:100%;">
+</a>
+
 ## Highlights
 
 * Generic utility to avoid N+1 DB queries, HTTP requests, etc.
 * Adapted Ruby implementation of battle-tested tools like [Haskell Haxl](https://github.com/facebook/Haxl), [JS DataLoader](https://github.com/facebook/dataloader), etc.
-* Parent objects don't have to know about children's requirements, batching is isolated.
-* Automatically caches previous queries.
-* Doesn't require to create custom classes.
-* Thread-safe (`BatchLoader#load`).
-* Has zero dependencies.
-* Works with any Ruby code, including REST APIs and GraphQL.
+* Batching is isolated and lazy, load data in batch where and when it's needed.
+* Automatically caches previous queries (identity map).
+* Thread-safe (`loader`).
+* No need to share batching through variables or custom defined classes.
+* No dependencies, no monkey-patches, no extra primitives such as Promises.
 
 ## Usage
 
@@ -47,19 +51,15 @@ def load_posts(ids)
   Post.where(id: ids)
 end
 
-def load_users(posts)
-  posts.map { |post| post.user }
-end
-
 posts = load_posts([1, 2, 3])  #      Posts      SELECT * FROM posts WHERE id IN (1, 2, 3)
                                #      _ ↓ _
                                #    ↙   ↓   ↘
-                               #   U    ↓    ↓   SELECT * FROM users WHERE id = 1
-users = load_users(post)       #   ↓    U    ↓   SELECT * FROM users WHERE id = 2
-                               #   ↓    ↓    U   SELECT * FROM users WHERE id = 3
+users = posts.map do |post|    #   U    ↓    ↓   SELECT * FROM users WHERE id = 1
+  post.user                    #   ↓    U    ↓   SELECT * FROM users WHERE id = 2
+end                            #   ↓    ↓    U   SELECT * FROM users WHERE id = 3
                                #    ↘   ↓   ↙
                                #      ¯ ↓ ¯
-users.map { |u| user.name }    #      Users
+puts users                     #      Users
 ```
 
 The naive approach would be to preload dependent objects on the top level:
@@ -84,22 +84,18 @@ def load_posts(ids)
   posts.each { |post| post.user = user_by_id[post.user_id] }
 end
 
-def load_users(posts)
-  posts.map { |post| post.user }
-end
-
 posts = load_posts([1, 2, 3])  #      Posts      SELECT * FROM posts WHERE id IN (1, 2, 3)
                                #      _ ↓ _      SELECT * FROM users WHERE id IN (1, 2, 3)
                                #    ↙   ↓   ↘
-                               #   U    ↓    ↓
-users = load_posts(post.user)  #   ↓    U    ↓
-                               #   ↓    ↓    U
+users = posts.map do |post|    #   U    ↓    ↓
+  post.user                    #   ↓    U    ↓
+end                            #   ↓    ↓    U
                                #    ↘   ↓   ↙
                                #      ¯ ↓ ¯
-users.map { |u| user.name }    #      Users
+puts users                     #      Users
 ```
 
-But the problem here is that `load_posts` now depends on the child association and knows that it has to preload the data for `load_users`. And it'll do it every time, even if it's not necessary. Can we do better? Sure!
+But the problem here is that `load_posts` now depends on the child association and knows that it has to preload data for future use. And it'll do it every time, even if it's not necessary. Can we do better? Sure!
 
 ### Basic example
 
@@ -110,56 +106,54 @@ def load_posts(ids)
   Post.where(id: ids)
 end
 
-def load_users(posts)
-  posts.map do |post|
-    BatchLoader.for(post.user_id).batch do |user_ids, batch_loader|
-      User.where(id: user_ids).each { |u| batch_loader.load(u.id, user) }
-    end
+def load_user(post)
+  BatchLoader.for(post.user_id).batch do |user_ids, loader|
+    User.where(id: user_ids).each { |user| loader.call(user.id, user) }
   end
 end
 
-posts = load_posts([1, 2, 3])         #      Posts      SELECT * FROM posts WHERE id IN (1, 2, 3)
-                                      #      _ ↓ _
-                                      #    ↙   ↓   ↘
-                                      #   BL   ↓    ↓
-users = load_users(posts)             #   ↓    BL   ↓
-                                      #   ↓    ↓    BL
-                                      #    ↘   ↓   ↙
-                                      #      ¯ ↓ ¯
-BatchLoader.sync!(users).map(&:name)  #      Users      SELECT * FROM users WHERE id IN (1, 2, 3)
+posts = load_posts([1, 2, 3])  #      Posts      SELECT * FROM posts WHERE id IN (1, 2, 3)
+                               #      _ ↓ _
+                               #    ↙   ↓   ↘
+users = posts.map do |post|    #   BL   ↓    ↓
+  load_user(post)              #   ↓    BL   ↓
+end                            #   ↓    ↓    BL
+                               #    ↘   ↓   ↙
+                               #      ¯ ↓ ¯
+puts users                     #      Users      SELECT * FROM users WHERE id IN (1, 2, 3)
 ```
 
 As we can see, batching is isolated and described right in a place where it's needed.
 
 ### How it works
 
-In general, `BatchLoader` returns a lazy object. In other programming languages it usually called Promise, but I personally prefer to call it lazy, since Ruby already uses the name in standard library :) Each lazy object knows which data it needs to load and how to batch the query. When all the lazy objects are collected it's possible to resolve them once without N+1 queries.
+In general, `BatchLoader` returns a lazy object. Each lazy object knows which data it needs to load and how to batch the query. As soon as you need to use the lazy objects, they will be automatically loaded once without N+1 queries.
 
-So, when we call `BatchLoader.for` we pass an item (`user_id`) which should be batched. For the `batch` method, we pass a block which uses all the collected items (`user_ids`):
+So, when we call `BatchLoader.for` we pass an item (`user_id`) which should be collected and used for batching later. For the `batch` method, we pass a block which will use all the collected items (`user_ids`):
 
 <pre>
-BatchLoader.for(post.<b>user_id</b>).batch do |<b>user_ids</b>, batch_loader|
+BatchLoader.for(post.<b>user_id</b>).batch do |<b>user_ids</b>, loader|
   ...
 end
 </pre>
 
-Inside the block we execute a batch query for our items (`User.where`). After that, all we have to do is to call `load` method and pass an item which was used in `BatchLoader.for` method (`user_id`) and the loaded object itself (`user`):
+Inside the block we execute a batch query for our items (`User.where`). After that, all we have to do is to call `loader` by passing an item which was used in `BatchLoader.for` method (`user_id`) and the loaded object itself (`user`):
 
 <pre>
-BatchLoader.for(post.<b>user_id</b>).batch do |user_ids, batch_loader|
-  User.where(id: user_ids).each { |u| batch_loader.load(<b>u.id</b>, <b>user</b>) }
+BatchLoader.for(post.<b>user_id</b>).batch do |user_ids, loader|
+  User.where(id: user_ids).each { |user| loader.call(<b>user.id</b>, <b>user</b>) }
 end
 </pre>
 
-Now we can resolve all the collected `BatchLoader` objects:
+When we call any method on the lazy object, it'll be automatically loaded through batching for all instantiated `BatchLoader`s:
 
 <pre>
-BatchLoader.sync!(users) # => SELECT * FROM users WHERE id IN (1, 2, 3)
+puts users # => SELECT * FROM users WHERE id IN (1, 2, 3)
 </pre>
 
 For more information, see the [Implementation details](#implementation-details) section.
 
-### REST API example
+### RESTful API example
 
 Now imagine we have a regular Rails app with N+1 HTTP requests:
 
@@ -187,8 +181,8 @@ As we can see, the code above will make N+1 HTTP requests, one for each post. Le
 ```ruby
 class Post < ApplicationRecord
   def rating_lazy
-    BatchLoader.for(post).batch do |posts, batch_loader|
-      Parallel.each(posts, in_threads: 10) { |post| batch_loader.load(post, post.rating) }
+    BatchLoader.for(post).batch do |posts, loader|
+      Parallel.each(posts, in_threads: 10) { |post| loader.call(post, post.rating) }
     end
   end
 
@@ -196,21 +190,22 @@ class Post < ApplicationRecord
 end
 ```
 
-`BatchLoader#load` is thread-safe. So, if `HttpClient` is also thread-safe, then with `parallel` gem we can execute all HTTP requests concurrently in threads (there are some benchmarks for [concurrent HTTP requests](https://github.com/exAspArk/concurrent_http_requests) in Ruby). Thanks to Matz, MRI releases GIL when thread hits blocking I/O – HTTP request in our case.
+`loader` is thread-safe. So, if `HttpClient` is also thread-safe, then with `parallel` gem we can execute all HTTP requests concurrently in threads (there are some benchmarks for [concurrent HTTP requests](https://github.com/exAspArk/concurrent_http_requests) in Ruby). Thanks to Matz, MRI releases GIL when thread hits blocking I/O – HTTP request in our case.
 
-Now we can resolve all `BatchLoader` objects in the controller:
+In the controller, all we have to do is to replace `post.rating` with the lazy `post.rating_lazy`:
 
 ```ruby
 class PostsController < ApplicationController
   def index
     posts = Post.limit(10)
     serialized_posts = posts.map { |post| {id: post.id, rating: post.rating_lazy} }
-    render json: BatchLoader.sync!(serialized_posts)
+
+    render json: serialized_posts
   end
 end
 ```
 
-`BatchLoader` caches the resolved values. To ensure that the cache is purged between requests in the app add the following middleware to your `config/application.rb`:
+`BatchLoader` caches the loaded values. To ensure that the cache is purged between requests in the app add the following middleware to your `config/application.rb`:
 
 ```ruby
 config.middleware.use BatchLoader::Middleware
@@ -220,8 +215,7 @@ See the [Caching](#caching) section for more information.
 
 ### GraphQL example
 
-With GraphQL using batching is particularly useful. You can't use usual techniques such as preloading associations in advance to avoid N+1 queries.
-Since you don't know which fields user is going to ask in a query.
+Batching is particularly useful with GraphQL. Using such techniques as preloading data in advance to avoid N+1 queries can be very complicated, since a user can ask for any available fields in a query.
 
 Let's take a look at the simple [graphql-ruby](https://github.com/rmosolgo/graphql-ruby) schema example:
 
@@ -246,7 +240,7 @@ UserType = GraphQL::ObjectType.define do
 end
 ```
 
-If we want to execute a simple query like:
+If we want to execute a simple query like the following, we will get N+1 queries for each `post.user`:
 
 ```ruby
 query = "
@@ -258,81 +252,79 @@ query = "
   }
 }
 "
-Schema.execute(query, variables: {}, context: {})
+Schema.execute(query)
 ```
 
-We will get N+1 queries for each `post.user`. To avoid this problem, all we have to do is to change the resolver to use `BatchLoader`:
+To avoid this problem, all we have to do is to change the resolver to return `BatchLoader`:
 
 ```ruby
 PostType = GraphQL::ObjectType.define do
   name "Post"
   field :user, !UserType, resolve: ->(post, args, ctx) do
-    BatchLoader.for(post.user_id).batch do |user_ids, batch_loader|
-      User.where(id: user_ids).each { |user| batch_loader.load(user.id, user) }
+    BatchLoader.for(post.user_id).batch do |user_ids, loader|
+      User.where(id: user_ids).each { |user| loader.call(user.id, user) }
     end
   end
 end
 ```
 
-And setup GraphQL with built-in `lazy_resolve` method:
+And setup GraphQL to use the built-in `lazy_resolve` method:
 
 ```ruby
 Schema = GraphQL::Schema.define do
   query QueryType
-  lazy_resolve BatchLoader, :sync
+  use BatchLoader::GraphQL
 end
 ```
 
+That's it.
+
 ### Caching
 
-By default `BatchLoader` caches the resolved values. You can test it by running something like:
+By default `BatchLoader` caches the loaded values. You can test it by running something like:
 
 ```ruby
 def user_lazy(id)
-  BatchLoader.for(id).batch do |ids, batch_loader|
-    User.where(id: ids).each { |user| batch_loader.load(user.id, user) }
+  BatchLoader.for(id).batch do |ids, loader|
+    User.where(id: ids).each { |user| loader.call(user.id, user) }
   end
 end
 
-user_lazy(1)      # no request
-# => <#BatchLoader>
+puts user_lazy(1) # SELECT * FROM users WHERE id IN (1)
+# => <#User:...>
+
+puts user_lazy(1) # no request
+# => <#User:...>
+```
 
-user_lazy(1).sync # SELECT * FROM users WHERE id IN (1)
-# => <#User>
+Usually, it's just enough to clear the cache between HTTP requests in the app. To do so, simply add the middleware:
 
-user_lazy(1).sync # no request
-# => <#User>
+```ruby
+use BatchLoader::Middleware
 ```
 
 To drop the cache manually you can run:
 
 ```ruby
-user_lazy(1).sync # SELECT * FROM users WHERE id IN (1)
-user_lazy(1).sync # no request
+puts user_lazy(1) # SELECT * FROM users WHERE id IN (1)
+puts user_lazy(1) # no request
 
 BatchLoader::Executor.clear_current
 
-user_lazy(1).sync # SELECT * FROM users WHERE id IN (1)
-```
-
-Usually, it's just enough to clear the cache between HTTP requests in the app. To do so, simply add the middleware:
-
-```ruby
-# calls "BatchLoader::Executor.clear_current" after each request
-use BatchLoader::Middleware
+puts user_lazy(1) # SELECT * FROM users WHERE id IN (1)
 ```
 
 In some rare cases it's useful to disable caching for `BatchLoader`. For example, in tests or after data mutations:
 
 ```ruby
 def user_lazy(id)
-  BatchLoader.for(id).batch(cache: false) do |ids, batch_loader|
+  BatchLoader.for(id).batch(cache: false) do |ids, loader|
     # ...
   end
 end
 
-user_lazy(1).sync # SELECT * FROM users WHERE id IN (1)
-user_lazy(1).sync # SELECT * FROM users WHERE id IN (1)
+puts user_lazy(1) # SELECT * FROM users WHERE id IN (1)
+puts user_lazy(1) # SELECT * FROM users WHERE id IN (1)
 ```
 
 ## Installation
@@ -353,7 +345,7 @@ Or install it yourself as:
 
 ## Implementation details
 
-Coming soon
+See the [slides](https://speakerdeck.com/exaspark/batching-a-powerful-way-to-solve-n-plus-1-queries) [37-42].
 
 ## Development
 
@@ -365,6 +357,22 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/exAspArk/batch-loader. 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.
 
+## Alternatives
+
+There are some other Ruby implementations for batching such as:
+
+* [shopify/graphql-batch](https://github.com/shopify/graphql-batch)
+* [sheerun/dataloader](https://github.com/sheerun/dataloader)
+
+However, `batch-loader` has some differences:
+
+* It is implemented for general usage and can be used not only with GraphQL. In fact, we use it for RESTful APIs and GraphQL on production at the same time.
+* It doesn't try to mimic implementations in other programming languages which have an asynchronous nature. So, it doesn't load extra dependencies to bring such primitives as Promises, which are not very popular in Ruby community.
+Instead, it uses the idea of lazy objects, which are included in the [Ruby standard library](https://ruby-doc.org/core-2.4.1/Enumerable.html#method-i-lazy). These lazy objects allow one to return the necessary data at the end when it's necessary.
+* It doesn't force you to share batching through variables or custom defined classes, just pass a block to the `batch` method.
+* It doesn't require to return an array of the loaded objects in the same order as the passed items. I find it difficult to satisfy these constraints: to sort the loaded objects and add `nil` values for the missing ones. Instead, it provides the `loader` lambda which simply maps an item to the loaded object.
+* It doesn't depend on any other external dependencies. For example, no need to load huge external libraries for thread-safety, the gem is thread-safe out of the box.
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/batch-loader.gemspec

@@ -9,13 +9,13 @@ Gem::Specification.new do |spec|
   spec.authors       = ["exAspArk"]
   spec.email         = ["exaspark@gmail.com"]
 
-  spec.summary       = %q{Simple tool to avoid N+1 DB queries, HTTP requests, etc.}
-  spec.description   = %q{Simple tool to avoid N+1 DB queries, HTTP requests, etc.}
+  spec.summary       = %q{Powerful tool to avoid N+1 DB or HTTP queries}
+  spec.description   = %q{Powerful tool to avoid N+1 DB or HTTP queries}
   spec.homepage      = "https://github.com/exAspArk/batch-loader"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
+    f.match(%r{^(spec|images)/})
   end
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }

data/lib/batch_loader.rb

@@ -1,67 +1,115 @@
+# frozen_string_literal: true
+
 require "batch_loader/version"
 require "batch_loader/executor_proxy"
 require "batch_loader/middleware"
+require "batch_loader/graphql"
 
 class BatchLoader
   NoBatchError = Class.new(StandardError)
-  BatchAlreadyExistsError = Class.new(StandardError)
 
   def self.for(item)
     new(item: item)
   end
 
-  def self.sync!(value)
-    case value
-    when Array
-      value.map! { |v| sync!(v) }
-    when Hash
-      value.each { |k, v| value[k] = sync!(v) }
-    when BatchLoader
-      sync!(value.sync)
-    else
-      value
-    end
-  end
-
-  attr_reader :item, :batch_block, :cache
-
   def initialize(item:)
     @item = item
   end
 
   def batch(cache: true, &batch_block)
-    raise BatchAlreadyExistsError if @batch_block
     @cache = cache
     @batch_block = batch_block
-    executor_for_block.add(item: item)
+    executor_proxy.add(item: @item)
+
+    singleton_class.class_eval { undef_method(:batch) }
+
     self
   end
 
-  def load(item, value)
-    executor_for_block.load(item: item, value: value)
+  def batch_loader?
+    true
   end
 
-  def sync
-    unless executor_for_block.value_loaded?(item: item)
-      batch_block.call(executor_for_block.list_items, self)
-      executor_for_block.delete_items
-    end
-    result = executor_for_block.loaded_value(item: item)
-    purge_cache unless cache
-    result
+  def respond_to?(method_name)
+    method_name == :batch_loader? || method_missing(:respond_to?, method_name)
   end
 
   private
 
-  def executor_for_block
-    @executor_for_block ||= begin
-      raise NoBatchError.new("Please provide a batch block first") unless batch_block
-      BatchLoader::ExecutorProxy.new(&batch_block)
+  def method_missing(method_name, *args, &block)
+    sync!.public_send(method_name, *args, &block)
+  end
+
+  def sync!
+    return self if @synced
+
+    ensure_batched
+    loaded_value = executor_proxy.loaded_value(item: @item)
+
+    if @cache
+      replace_with!(loaded_value)
+      @synced = true
+      self
+    else
+      purge_cache
+      loaded_value
+    end
+  end
+
+  def ensure_batched
+    return if executor_proxy.value_loaded?(item: @item)
+
+    items = executor_proxy.list_items
+    loader = ->(item, value) { executor_proxy.load(item: item, value: value) }
+    items.each { |item| loader.call(item, nil) }
+    @batch_block.call(items, loader)
+    executor_proxy.delete(items: items)
+  end
+
+  def singleton_class
+    class << self
+      self
+    end
+  end
+
+  def replace_with!(value)
+    BatchLoader.send(:without_warnings) do
+      ignore_method_names = %i[singleton_method_added].freeze
+      singleton_class.class_eval do
+        (value.methods - ignore_method_names).each do |method_name|
+          define_method(method_name) do |*args, &block|
+            value.public_send(method_name, *args, &block)
+          end
+        end
+      end
     end
   end
 
   def purge_cache
-    executor_for_block.unload_value(item: item)
-    executor_for_block.add(item: item)
+    executor_proxy.unload_value(item: @item)
+    executor_proxy.add(item: @item)
+  end
+
+  def executor_proxy
+    @executor_proxy ||= begin
+      raise NoBatchError.new("Please provide a batch block first") unless @batch_block
+      BatchLoader::ExecutorProxy.new(&@batch_block)
+    end
+  end
+
+  class << self
+    private
+
+    def without_warnings(&block)
+      warning_level = $VERBOSE
+      $VERBOSE = nil
+      block.call
+      $VERBOSE = warning_level
+    end
+  end
+
+  without_warnings do
+    leave_method_names = %i[batch batch_loader? respond_to?].freeze
+    (instance_methods - leave_method_names).each { |method_name| undef_method(method_name) }
   end
 end

data/lib/batch_loader/executor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class BatchLoader
   class Executor
     NAMESPACE = :batch_loader

data/lib/batch_loader/executor_proxy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "batch_loader/executor"
 
 class BatchLoader
@@ -11,15 +13,15 @@ class BatchLoader
     end
 
     def add(item:)
-      items << item
+      items_to_load << item
     end
 
     def list_items
-      items.to_a
+      items_to_load.to_a
     end
 
-    def delete_items
-      global_executor.items_by_block[@block_hash_key] = Set.new
+    def delete(items:)
+      global_executor.items_by_block[@block_hash_key] = items_to_load - items
     end
 
     def load(item:, value:)
@@ -40,7 +42,7 @@ class BatchLoader
 
     private
 
-    def items
+    def items_to_load
       global_executor.items_by_block[@block_hash_key]
     end
 

data/lib/batch_loader/graphql.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class BatchLoader
+  class GraphQL
+    class Wrapper
+      def initialize(batch_loader)
+        @batch_loader = batch_loader
+      end
+
+      def sync
+        @batch_loader
+      end
+    end
+
+    def self.use(schema_definition)
+      schema_definition.lazy_resolve(BatchLoader::GraphQL::Wrapper, :sync)
+      schema_definition.instrument(:field, self)
+    end
+
+    def self.instrument(type, field)
+      old_resolve_proc = field.resolve_proc
+      new_resolve_proc = ->(object, arguments, context) do
+        result = old_resolve_proc.call(object, arguments, context)
+        result.respond_to?(:batch_loader?) ? BatchLoader::GraphQL::Wrapper.new(result) : result
+      end
+
+      field.redefine { resolve(new_resolve_proc) }
+    end
+  end
+end

data/lib/batch_loader/middleware.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class BatchLoader
   class Middleware
     def initialize(app)

data/lib/batch_loader/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class BatchLoader
-  VERSION = "0.3.0"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: batch-loader
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.0
 platform: ruby
 authors:
 - exAspArk
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-08-03 00:00:00.000000000 Z
+date: 2017-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,7 +80,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
-description: Simple tool to avoid N+1 DB queries, HTTP requests, etc.
+description: Powerful tool to avoid N+1 DB or HTTP queries
 email:
 - exaspark@gmail.com
 executables: []
@@ -104,6 +104,7 @@ files:
 - lib/batch_loader.rb
 - lib/batch_loader/executor.rb
 - lib/batch_loader/executor_proxy.rb
+- lib/batch_loader/graphql.rb
 - lib/batch_loader/middleware.rb
 - lib/batch_loader/version.rb
 homepage: https://github.com/exAspArk/batch-loader
@@ -129,5 +130,5 @@ rubyforge_project:
 rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
-summary: Simple tool to avoid N+1 DB queries, HTTP requests, etc.
+summary: Powerful tool to avoid N+1 DB or HTTP queries
 test_files: []