batch-loader 1.4.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: db5859fbd35a95890bfe66bddeb67fd540575186
-  data.tar.gz: ab0ed01e82d34f997970d6b73d6f0953a8640bb2
+SHA256:
+  metadata.gz: 061a141c0204a3e32aa437b0258e0051b1a0d725de948a762f2444d6994ebfb8
+  data.tar.gz: 9ca768f5ecbe6fe8b72edd4a9161d7aee635023ce111f26f2406a71633a2e2ad
 SHA512:
-  metadata.gz: 2a18ca320ffb58e0e7f696c204bb070da418560e2a3c42621259532fb23ea364fc38bf148e95dfa49281892b47d3cbd8f00fa6800df9c213faf1e9ff7fd4d8ad
-  data.tar.gz: b6d1aedc6ea85f6dd40959350b55f8267e3ab4a80dfe61f8ed4aa3710144a14d0f434858d77c428653dba4c1243a92bedd6ed84c75cff90b200c1d6d348ea0e9
+  metadata.gz: c09ec97852edb3ff184a5e5f4fb90e615cdf86b65920a7e9da56e5e4fd633e99ca5252d48a08b8802f860a960539fe5adafebf9b26b910ebe03423fa66b58b3f
+  data.tar.gz: 14769f25d9e61311700997c3008f6df75eaf7b5fbce5db121a36dacbf483246d145862f63c813d4273d30f626690a1941fb17abd1e31b8b91f90d477c67001a1

data/.travis.yml

@@ -1,23 +1,13 @@
-sudo: false
 language: ruby
-before_install: gem install bundler -v 1.17.1
-matrix:
-  include:
-    - gemfile: graphql-1.7.gemfile
-      env: GRAPHQL_RUBY_VERSION=1_7 CI=true
-      rvm: 2.3.8
-    - gemfile: graphql-1.8.gemfile
-      env: GRAPHQL_RUBY_VERSION=1_8 CI=true
-      rvm: 2.3.8
-    - gemfile: graphql-1.7.gemfile
-      env: GRAPHQL_RUBY_VERSION=1_7 CI=true
-      rvm: 2.4.5
-    - gemfile: graphql-1.8.gemfile
-      env: GRAPHQL_RUBY_VERSION=1_8 CI=true
-      rvm: 2.4.5
-    - gemfile: graphql-1.7.gemfile
-      env: GRAPHQL_RUBY_VERSION=1_7 CI=true
-      rvm: 2.5.3
-    - gemfile: graphql-1.8.gemfile
-      env: GRAPHQL_RUBY_VERSION=1_8 CI=true
-      rvm: 2.5.3
+before_install: gem install bundler -v 2.0.1
+rvm:
+  - 2.3.8
+  - 2.4.9
+  - 2.5.7
+  - 2.6.5
+  - 2.7.0
+env:
+  - CI=true
+gemfile:
+  - graphql-1.7.gemfile
+  - graphql-latest.gemfile

data/CHANGELOG.md

@@ -12,6 +12,35 @@ that you can set version constraints properly.
 
 * WIP
 
+#### [v1.5.0](https://github.com/exAspArk/batch-loader/compare/v1.4.1...v1.5.0)
+
+* `Added`: Support for GraphQL Interpreter. [#62](https://github.com/exAspArk/batch-loader/pull/62)
+* `Deprecated`: `BatchLoader.for` in GraphQL. [#62](https://github.com/exAspArk/batch-loader/pull/62)
+
+Please use `BatchLoader::GraphQL.for` instead:
+
+```rb
+field :user, UserType, null: false
+
+def user # resolver
+  BatchLoader::GraphQL.for...
+end
+```
+
+Or wrap a BatchLoader instance with `BatchLoader::GraphQL.wrap`:
+
+```rb
+field :user, UserType, null: false
+
+def user # resolver
+  BatchLoader::GraphQL.wrap(lazy_user)
+end
+
+def lazy_user
+  BatchLoader.for...
+end
+```
+
 #### [v1.4.1](https://github.com/exAspArk/batch-loader/compare/v1.4.0...v1.4.1)
 
 * `Fixes`: Does not allow mutating and corrupting a list of items in a `batch` block. [#46](https://github.com/exAspArk/batch-loader/pull/46)

data/README.md

@@ -37,9 +37,9 @@ Developers from these companies use `BatchLoader`:
   * [Replacing methods](#replacing-methods)
 * [Installation](#installation)
 * [API](#api)
+* [Related tools](#related-tools)
 * [Implementation details](#implementation-details)
 * [Development](#development)
-* [Related gems](#related-gems)
 * [Contributing](#contributing)
 * [Alternatives](#alternatives)
 * [License](#license)
@@ -235,23 +235,38 @@ Batching is particularly useful with GraphQL. Using such techniques as preloadin
 Let's take a look at the simple [graphql-ruby](https://github.com/rmosolgo/graphql-ruby) schema example:
 
 ```ruby
-Schema = GraphQL::Schema.define do
-  query QueryType
+class MyProjectSchema < GraphQL::Schema
+  query Types::QueryType
 end
 
-QueryType = GraphQL::ObjectType.define do
-  name "Query"
-  field :posts, !types[PostType], resolve: ->(obj, args, ctx) { Post.all }
+module Types
+  class QueryType < Types::BaseObject
+    field :posts, [PostType], null: false
+
+    def posts
+      Post.all
+    end
+  end
 end
 
-PostType = GraphQL::ObjectType.define do
-  name "Post"
-  field :user, !UserType, resolve: ->(post, args, ctx) { post.user } # N+1 queries
+module Types
+  class PostType < Types::BaseObject
+    name "Post"
+
+    field :user, UserType, null: false
+
+    def user
+      post.user # N+1 queries
+    end
+  end
 end
 
-UserType = GraphQL::ObjectType.define do
-  name "User"
-  field :name, !types.String
+module Types
+  class UserType < Types::BaseObject
+    name "User"
+
+    field :name, String, null: false
+  end
 end
 ```
 
@@ -267,17 +282,22 @@ query = "
   }
 }
 "
-Schema.execute(query)
+MyProjectSchema.execute(query)
 ```
 
 To avoid this problem, all we have to do is to change the resolver to return `BatchLoader::GraphQL` ([#32](https://github.com/exAspArk/batch-loader/pull/32) explains why not just `BatchLoader`):
 
 ```ruby
-PostType = GraphQL::ObjectType.define do
-  name "Post"
-  field :user, !UserType, resolve: ->(post, args, ctx) do
-    BatchLoader::GraphQL.for(post.user_id).batch do |user_ids, loader|
-      User.where(id: user_ids).each { |user| loader.call(user.id, user) }
+module Types
+  class PostType < Types::BaseObject
+    name "Post"
+
+    field :user, UserType, null: false
+
+    def user
+      BatchLoader::GraphQL.for(post.user_id).batch do |user_ids, loader|
+        User.where(id: user_ids).each { |user| loader.call(user.id, user) }
+      end
     end
   end
 end
@@ -286,8 +306,8 @@ end
 And setup GraphQL to use the built-in `lazy_resolve` method:
 
 ```ruby
-Schema = GraphQL::Schema.define do
-  query QueryType
+class MyProjectSchema < GraphQL::Schema
+  query Types::QueryType
   use BatchLoader::GraphQL
 end
 ```
@@ -304,7 +324,7 @@ BatchLoader.for(post.user_id).batch(default_value: NullUser.new) do |user_ids, l
 end
 ```
 
-For batches where the value is some kind of collection, such as an Array or Hash, `loader` also supports being called with a block, which yields the _current_ value, and returns the _next_ value. This is extremely useful for 1:Many relationships:
+For batches where the value is some kind of collection, such as an Array or Hash, `loader` also supports being called with a block, which yields the _current_ value, and returns the _next_ value. This is extremely useful for 1:Many (`has_many`) relationships:
 
 ```ruby
 BatchLoader.for(user.id).batch(default_value: []) do |user_ids, loader|
@@ -441,6 +461,18 @@ end
 | `loader`          | -                                                                    | Lambda which should be called to load values loaded in batch.                         |
 | `args`            | `{default_value: nil, cache: true, replace_methods: true, key: nil}` | Arguments passed to the `batch` method.                                               |
 
+## Related tools
+
+These gems are built by using `BatchLoader`:
+
+* [decidim-core](https://github.com/decidim/decidim/) – participatory democracy framework made with Ruby on Rails.
+* [ams_lazy_relationships](https://github.com/Bajena/ams_lazy_relationships/) – ActiveModel Serializers add-on for eliminating N+1 queries.
+* [batch-loader-active-record](https://github.com/mathieul/batch-loader-active-record/) – ActiveRecord lazy association generator to avoid N+1 DB queries.
+
+`BatchLoader` in other programming languages:
+
+* [batch_loader](https://github.com/exaspark/batch_loader) - Elixir implementation.
+
 ## Implementation details
 
 See the [slides](https://speakerdeck.com/exaspark/batching-a-powerful-way-to-solve-n-plus-1-queries) [37-42].
@@ -451,14 +483,6 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
-## Related gems
-
-These gems are built by using `BatchLoader`:
-
-* [decidim-core](https://github.com/decidim/decidim/) – participatory democracy framework made with Ruby on Rails.
-* [ams_lazy_relationships](https://github.com/Bajena/ams_lazy_relationships/) – ActiveModel Serializers add-on for eliminating N+1 queries.
-* [batch-loader-active-record](https://github.com/mathieul/batch-loader-active-record/) – ActiveRecord lazy association generator to avoid N+1 DB queries.
-
 ## Contributing
 
 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.

data/graphql-1.7.gemfile

@@ -2,6 +2,6 @@ source "https://rubygems.org"
 
 gem 'coveralls'
 
-gem "graphql", "~> 1.7"
+gem "graphql", "~> 1.7.0"
 
 gemspec

data/{graphql-1.8.gemfile → graphql-latest.gemfile}

@@ -2,6 +2,6 @@ source "https://rubygems.org"
 
 gem 'coveralls'
 
-gem "graphql", "~> 1.8"
+gem "graphql", ">= 1.8"
 
 gemspec

data/lib/batch_loader/graphql.rb

@@ -4,20 +4,40 @@ class BatchLoader
   class GraphQL
     def self.use(schema_definition)
       schema_definition.lazy_resolve(BatchLoader::GraphQL, :sync)
-      # for graphql gem versions <= 1.8.6 which work with BatchLoader instead of BatchLoader::GraphQL
-      schema_definition.instrument(:field, self)
+
+      # in cases when BatchLoader is being used instead of BatchLoader::GraphQL
+      if schema_definition.respond_to?(:interpreter?) && schema_definition.interpreter?
+        schema_definition.tracer(self)
+      else
+        schema_definition.instrument(:field, self)
+      end
+    end
+
+    def self.trace(event, _data)
+      if event == 'execute_field'
+        result = yield
+        result.respond_to?(:__sync) ? wrap_with_warning(result) : result
+      else
+        yield
+      end
     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?(:__sync) ? BatchLoader::GraphQL.wrap(result) : result
+        result.respond_to?(:__sync) ? wrap_with_warning(result) : result
       end
 
       field.redefine { resolve(new_resolve_proc) }
     end
 
+    def self.wrap_with_warning(batch_loader)
+      warn "DEPRECATION WARNING: using BatchLoader.for in GraphQL is deprecated. Use BatchLoader::GraphQL.for instead or return BatchLoader::GraphQL.wrap from your resolver."
+      wrap(batch_loader)
+    end
+    private_class_method :wrap_with_warning
+
     def self.wrap(batch_loader)
       BatchLoader::GraphQL.new.tap do |graphql|
         graphql.batch_loader = batch_loader

data/lib/batch_loader/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class BatchLoader
-  VERSION = "1.4.1"
+  VERSION = "1.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: batch-loader
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.5.0
 platform: ruby
 authors:
 - exAspArk
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-24 00:00:00.000000000 Z
+date: 2020-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -128,7 +128,7 @@ files:
 - bin/console
 - bin/setup
 - graphql-1.7.gemfile
-- graphql-1.8.gemfile
+- graphql-latest.gemfile
 - lib/batch-loader.rb
 - lib/batch_loader.rb
 - lib/batch_loader/executor.rb
@@ -155,8 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Powerful tool to avoid N+1 DB or HTTP queries