graphql-batch 0.4.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fccdeee0358f45c6750102fa77b7537f11d4a269a40985be5e8c01db1314b346
-  data.tar.gz: ca0737882a1d16189c262e30e113deffb46d4ed50faabca99f3b81f2c317ed9a
+  metadata.gz: afe26d607949310c337c3f88cb6f356ccd51923d841fa1e7e8840f0fa5b34012
+  data.tar.gz: 1f45b62562ef558a6f6b59479b198fdb548b8f03f061ebb0e6c51b6cff74c6b4
 SHA512:
-  metadata.gz: 8edbbe8673b1581b2927fed0ed4af9370f7009d0662cac952bebe0cc00cec2bf32fafe4eee092af47666e61f3f8a09ec3298d95715a7d6436e91af4dacfc2f02
-  data.tar.gz: 3b4cd32b2f65e7af83394a151df55f9880b8d0381d687c1135dfb541a9dd90e4bdaca8071d5aae68976ae176e3bc74304ae639f884dcad3e26249abd4e4c1334
+  metadata.gz: 7416844cffe48e01ca8640382e831cafdd1d64efcbcb927677a2d8833a3883400806cb94f16c8057d9c0f15ca543640b8084ba7616bb2b7376fa21f75a366179
+  data.tar.gz: 7473cb5eb3893fc61b0be940c28a8582a3316e912909ec7d2c8d1aeb9f01b1011b88c3ca754330f48152276ed0463e39508b625b5351800a53254dfc86669e5f

data/.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: Tests
+
+on:
+  - push
+  - pull_request
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [2.7, 3.1, 3.3]
+        graphql_version: ['~> 1.12.18', '~> 1.13', '~> 2.0']
+        include:
+          - ruby: 2.4
+            graphql_version: '~> 1.12.18'
+          - ruby: 2.4
+            graphql_version: '~> 1.13'
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        bundler-cache: true
+        ruby-version: ${{ matrix.ruby }}
+      env:
+        GRAPHQL_VERSION: ${{ matrix.graphql_version }}
+    - run: bundle exec rake

data/.github/workflows/cla.yml

@@ -0,0 +1,22 @@
+name: Contributor License Agreement (CLA)
+
+on:
+  pull_request_target:
+    types: [opened, synchronize]
+  issue_comment:
+    types: [created]
+
+jobs:
+  cla:
+    runs-on: ubuntu-latest
+    if: |
+      (github.event.issue.pull_request
+        && !github.event.issue.pull_request.merged_at
+        && contains(github.event.comment.body, 'signed')
+      )
+      || (github.event.pull_request && !github.event.pull_request.merged)
+    steps:
+      - uses: Shopify/shopify-cla-action@v1
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          cla-token: ${{ secrets.CLA_TOKEN }}

data/.rubocop.yml

@@ -1,6 +1,11 @@
+inherit_gem:
+  rubocop-shopify: rubocop.yml
+
 inherit_from:
-  - https://shopify.github.io/ruby-style-guide/rubocop.yml
   - .rubocop_todo.yml
 
 AllCops:
-  TargetRubyVersion: 2.3
+  SuggestExtensions: false
+  TargetRubyVersion: 2.7
+  Exclude:
+    - vendor/**/*

data/.rubocop_todo.yml

@@ -56,6 +56,13 @@ Layout/SpaceInsideParens:
   Exclude:
     - 'test/loader_test.rb'
 
+# Offense count: 3
+Lint/MissingSuper:
+  Exclude:
+    - 'test/executor_test.rb'
+    - 'test/loader_test.rb'
+    - 'test/support/loaders.rb'
+
 # Offense count: 5
 # Cop supports --auto-correct.
 # Configuration parameters: IgnoreEmptyBlocks, AllowUnusedKeywordArguments.

data/Gemfile

@@ -3,4 +3,7 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'graphql', ENV['GRAPHQL_VERSION'] if ENV['GRAPHQL_VERSION']
-gem 'rubocop', '~> 0.78.0', require: false
+if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.4.0')
+  gem 'rubocop', '~> 1.12.0', require: false
+  gem "rubocop-shopify", '~> 1.0.7', require: false
+end

data/README.md

@@ -1,6 +1,6 @@
 # GraphQL::Batch
 
-[![Build Status](https://travis-ci.org/Shopify/graphql-batch.svg?branch=master)](https://travis-ci.org/Shopify/graphql-batch)
+[![Build Status](https://github.com/Shopify/graphql-batch/actions/workflows/ci.yml/badge.svg)](https://github.com/Shopify/graphql-batch/actions)
 [![Gem Version](https://badge.fury.io/rb/graphql-batch.svg)](https://rubygems.org/gems/graphql-batch)
 
 Provides an executor for the [`graphql` gem](https://github.com/rmosolgo/graphql-ruby) which allows queries to be batched.
@@ -50,7 +50,7 @@ end
 
 Use `GraphQL::Batch` as a plugin in your schema _after_ specifying the mutation
 so that `GraphQL::Batch` can extend the mutation fields to clear the cache after
-they are resolved (for graphql >= `1.5.0`).
+they are resolved.
 
 ```ruby
 class MySchema < GraphQL::Schema
@@ -61,16 +61,6 @@ class MySchema < GraphQL::Schema
 end
 ```
 
-For pre `1.5.0` versions:
-
-```ruby
-MySchema = GraphQL::Schema.define do
-  query MyQueryType
-
-  GraphQL::Batch.use(self)
-end
-```
-
 #### Field Usage
 
 The loader class can be used from the resolver for a graphql field by calling `.for` with the grouping arguments to get a loader instance, then call `.load` on that instance with the key to load.
@@ -132,9 +122,7 @@ def all_collections
   Promise.all([
     CountLoader.for(Shop, :smart_collections).load(context.shop_id),
     CountLoader.for(Shop, :custom_collections).load(context.shop_id),
-  ]).then do |results|
-    results.reduce(&:+)
-  end
+  ]).then(&:sum)
 end
 ```
 
@@ -152,22 +140,38 @@ def product(id:)
 end
 ```
 
+### Priming the Cache
+
+You can prime the loader cache with a specific value, which can be useful in certain situations.
+
+```ruby
+def liked_products
+  liked_products = Product.where(liked: true).load
+  liked_products.each do |product|
+    RecordLoader.for(Product).prime(product.id, product)
+  end
+end
+```
+
+Priming will add key/value to the loader cache only if it didn't exist before.
+
+
 ## Unit Testing
 
 Your loaders can be tested outside of a GraphQL query by doing the
-batch loads in a block passed to GraphQL::Batch.batch.  That method
+batch loads in a block passed to `GraphQL::Batch.batch`. That method
 will set up thread-local state to store the loaders, batch load any
 promise returned from the block then clear the thread-local state
 to avoid leaking state between tests.
 
 ```ruby
-  def test_single_query
-    product = products(:snowboard)
-    title = GraphQL::Batch.batch do
-      RecordLoader.for(Product).load(product.id).then(&:title)
-    end
-    assert_equal product.title, title
+def test_single_query
+  product = products(:snowboard)
+  title = GraphQL::Batch.batch do
+    RecordLoader.for(Product).load(product.id).then(&:title)
   end
+  assert_equal product.title, title
+end
 ```
 
 ## Development

data/Rakefile

@@ -7,9 +7,13 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-task :rubocop do
-  require 'rubocop/rake_task'
-  RuboCop::RakeTask.new
-end
+task(default: :test)
+
+if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.4.0')
+  task :rubocop do
+    require 'rubocop/rake_task'
+    RuboCop::RakeTask.new
+  end
 
-task(default: [:test, :rubocop])
+  task(default: :rubocop)
+end

data/examples/active_storage_loader.rb

@@ -0,0 +1,75 @@
+####
+# This is a loader for has_one_attached and has_many_attached Active Storage attachments
+# To load a variant for an attachment, 2 queries are required
+# Using preloading via the includes method.
+####
+
+####
+# The model with an attached image and many attached pictures
+####
+
+# class Event < ApplicationRecord
+#   has_one_attached :image
+#   has_many_attached :pictures
+# end
+
+####
+# An example data type using the Loaders::ActiveStorageLoader
+####
+
+# class Types::EventType < Types::BaseObject
+#   graphql_name 'Event'
+#
+#   field :id, ID, null: false
+#   field :image, String, null: true
+#   field :pictures, String, null: true
+#
+#   def image
+#     Loaders::ActiveStorageLoader.for(:Event, :image).load(object.id).then do |image|
+#       Rails.application.routes.url_helpers.url_for(
+#         image.variant({ quality: 75 })
+#       )
+#     end
+#   end
+#
+#   def pictures
+#     Loaders::ActiveStorageLoader.for(:Event, :pictures, association_type: :has_many_attached).load(object.id).then do |pictures|
+#       pictures.map do |picture|
+#         Rails.application.routes.url_helpers.url_for(
+#           picture.variant({ quality: 75 })
+#         )
+#       end
+#     end
+#   end
+# end
+module Loaders
+  class ActiveStorageLoader < GraphQL::Batch::Loader
+    attr_reader :record_type, :attachment_name, :association_type # should be has_one_attached or has_many_attached
+
+    def initialize(record_type, attachment_name, association_type: :has_one_attached)
+      super()
+      @record_type = record_type
+      @attachment_name = attachment_name
+      @association_type = association_type
+    end
+
+    def perform(record_ids)
+      # find records and fulfill promises
+      attachments = ActiveStorage::Attachment.includes(:blob).where(
+        record_type: record_type, record_id: record_ids, name: attachment_name
+      )
+
+      if @association_type == :has_one_attached
+        attachments.each do |attachment|
+          fulfill(attachment.record_id, attachment)
+        end
+
+        record_ids.each { |id| fulfill(id, nil) unless fulfilled?(id) }
+      else
+        record_ids.each do |record_id|
+          fulfill(record_id, attachments.select { |attachment| attachment.record_id == record_id })
+        end
+      end
+    end
+  end
+end

data/examples/association_loader.rb

@@ -5,6 +5,7 @@ class AssociationLoader < GraphQL::Batch::Loader
   end
 
   def initialize(model, association_name)
+    super()
     @model = model
     @association_name = association_name
     validate
@@ -35,7 +36,7 @@ class AssociationLoader < GraphQL::Batch::Loader
   end
 
   def preload_association(records)
-    ::ActiveRecord::Associations::Preloader.new.preload(records, @association_name)
+    ::ActiveRecord::Associations::Preloader.new(records: records, associations: @association_name).call
   end
 
   def read_association(record)

data/examples/http_loader.rb

@@ -35,22 +35,30 @@
 #     }
 #   GQL
 
+# An example loader which is blocking and synchronous as a whole, but executes all of its operations concurrently.
 module Loaders
   class HTTPLoader < GraphQL::Batch::Loader
     def initialize(host:, size: 4, timeout: 4)
+      super()
       @host = host
       @size = size
       @timeout = timeout
     end
 
     def perform(operations)
+      # This fans out and starts off all the concurrent work, which starts and
+      # immediately returns Concurrent::Promises::Future` objects for each operation.
       futures = operations.map do |operation|
         Concurrent::Promises.future do
           pool.with { |connection| operation.call(connection) }
         end
       end
+      # At this point, all of the concurrent work has been started.
+
+      # This converges back in, waiting on each concurrent future to finish, and fulfilling each
+      # (non-concurrent) Promise.rb promise.
       operations.each_with_index.each do |operation, index|
-        fulfill(operation, futures[index].value)
+        fulfill(operation, futures[index].value) # .value is a blocking call
       end
     end
 

data/examples/record_loader.rb

@@ -1,5 +1,6 @@
 class RecordLoader < GraphQL::Batch::Loader
   def initialize(model, column: model.primary_key, where: nil)
+    super()
     @model = model
     @column = column.to_s
     @column_type = model.type_for_attribute(@column)

data/examples/window_key_loader.rb

@@ -0,0 +1,81 @@
+####
+# This is a has_many loader which takes advantage of Postgres'
+# windowing functionality to load the first N records for
+# a given relationship.
+####
+
+####
+# An example data type using the WindowKeyLoader
+####
+
+# class Types::CategoryType < Types::BaseObject
+#   graphql_name 'Category'
+
+#   field :id, ID, null: false
+#   field :events, [Types::EventType], null: false do
+#     argument :first, Int, required: false, default_value: 5
+#   end
+
+#   def events(first:)
+#     WindowKeyLoader.for(
+#       Event,
+#       :category_id,
+#       limit: first, order_col: :start_time, order_dir: :desc
+#     ).load(object.id)
+#   end
+# end
+
+####
+# The SQL that is produced
+####
+
+# SELECT
+#   "events".*
+# FROM (
+#   SELECT
+#     "events".*,
+#     row_number() OVER (PARTITION BY category_id ORDER BY start_time DESC) AS rank
+#   FROM
+#     "events"
+#   WHERE
+#     "events"."category_id" IN(1, 2, 3, 4, 5)) AS events
+# WHERE (rank <= 5)
+
+class WindowKeyLoader < GraphQL::Batch::Loader
+  attr_reader :model, :foreign_key, :limit, :order_col, :order_dir
+
+  def initialize(model, foreign_key, limit:, order_col:, order_dir: :asc)
+    super()
+    @model = model
+    @foreign_key = foreign_key
+    @limit = limit
+    @order_col = order_col
+    @order_dir = order_dir
+  end
+
+  def perform(foreign_ids)
+    # build the sub-query, limiting results by foreign key at this point
+    # we don't want to execute this query but get its SQL to be used later
+    ranked_from =
+      model.select(
+        "*",
+        "row_number() OVER (
+          PARTITION BY #{foreign_key} ORDER BY #{order_col} #{order_dir}
+        ) as rank"
+      ).where(foreign_key => foreign_ids).to_sql
+
+    # use the sub-query from above to query records which have a rank
+    # value less than or equal to our limit
+    records =
+      model.from("(#{ranked_from}) as #{model.table_name}").where(
+        "rank <= #{limit}"
+      ).to_a
+
+    # match records and fulfill promises
+    foreign_ids.each do |foreign_id|
+      matching_records =
+        records.select { |r| foreign_id == r.send(foreign_key) }
+      fulfill(foreign_id, matching_records)
+    end
+  end
+end

data/graphql-batch.gemspec

@@ -1,7 +1,4 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'graphql/batch/version'
+require_relative 'lib/graphql/batch/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "graphql-batch"
@@ -20,7 +17,7 @@ Gem::Specification.new do |spec|
 
   spec.metadata['allowed_push_host'] = "https://rubygems.org"
 
-  spec.add_runtime_dependency "graphql", ">= 1.3", "< 2"
+  spec.add_runtime_dependency "graphql", ">= 1.12.18", "< 3"
   spec.add_runtime_dependency "promise.rb", "~> 0.7.2"
 
   spec.add_development_dependency "byebug" if RUBY_ENGINE == 'ruby'

data/lib/graphql/batch/loader.rb

@@ -34,7 +34,7 @@ module GraphQL::Batch
         unless executor
           raise GraphQL::Batch::NoExecutorError, 'Cannot create loader without'\
             ' an Executor. Wrap the call to `for` with `GraphQL::Batch.batch`'\
-            ' or use `GraphQL::Batch::Setup` as a query instrumenter if'\
+            ' or use `GraphQL::Batch::SetupMultiplex` as a query instrumenter if'\
             ' using with `graphql-ruby`'
         end
 
@@ -44,6 +44,13 @@ module GraphQL::Batch
 
     attr_accessor :loader_key, :executor
 
+    def initialize
+      @loader_key = nil
+      @executor = nil
+      @queue = nil
+      @cache = nil
+    end
+
     def load(key)
       cache[cache_key(key)] ||= begin
         queue << key
@@ -55,16 +62,29 @@ module GraphQL::Batch
       ::Promise.all(keys.map { |key| load(key) })
     end
 
+    def prime(key, value)
+      cache[cache_key(key)] ||= ::Promise.resolve(value).tap { |p| p.source = self }
+    end
+
     def resolve #:nodoc:
       return if resolved?
       load_keys = queue
       @queue = nil
-      perform(load_keys)
+
+      around_perform do
+        perform(load_keys)
+      end
+
       check_for_broken_promises(load_keys)
     rescue => err
       reject_pending_promises(load_keys, err)
     end
 
+    # Interface to add custom code for purposes such as instrumenting the performance of the loader.
+    def around_perform
+      yield
+    end
+
     # For Promise#sync
     def wait #:nodoc:
       if executor
@@ -95,7 +115,15 @@ module GraphQL::Batch
 
     # Returns true when the key has already been fulfilled, otherwise returns false
     def fulfilled?(key)
-      promise_for(key).fulfilled?
+      promise = promise_for(key)
+      # When a promise is fulfilled through this class, it will either:
+      #   become fulfilled, if fulfilled with a literal value
+      #   become pending with a new source if fulfilled with a promise
+      # Either of these is acceptable, promise.rb will automatically re-wait
+      # on the new source promise as needed.
+      return true if promise.fulfilled?
+
+      promise.pending? && promise.source != self
     end
 
     # Must override to load the keys and call #fulfill for each key
@@ -140,7 +168,13 @@ module GraphQL::Batch
 
     def check_for_broken_promises(load_keys)
       load_keys.each do |key|
-        next unless promise_for(key).pending?
+        promise = promise_for(key)
+        # When a promise is fulfilled through this class, it will either:
+        #   become not pending, if fulfilled with a literal value
+        #   become pending with a new source if fulfilled with a promise
+        # Either of these is acceptable, promise.rb will automatically re-wait
+        # on the new source promise as needed.
+        next unless promise.pending? && promise.source == self
 
         reject(key, ::Promise::BrokenError.new("#{self.class} didn't fulfill promise for key #{key.inspect}"))
       end

data/lib/graphql/batch/setup_multiplex.rb

@@ -6,15 +6,25 @@ module GraphQL::Batch
     end
 
     def before_multiplex(multiplex)
-      Setup.start_batching(@executor_class)
+      GraphQL::Batch::Executor.start_batch(@executor_class)
     end
 
     def after_multiplex(multiplex)
-      Setup.end_batching
+      GraphQL::Batch::Executor.end_batch
     end
 
-    def instrument(type, field)
-      Setup.instrument_field(@schema, type, field)
+    module Trace
+      def initialize(executor_class:, **_rest)
+        @executor_class = executor_class
+        super
+      end
+
+      def execute_multiplex(multiplex:)
+        GraphQL::Batch::Executor.start_batch(@executor_class)
+        super
+      ensure
+        GraphQL::Batch::Executor.end_batch
+      end
     end
   end
 end

data/lib/graphql/batch/version.rb

@@ -1,5 +1,5 @@
 module GraphQL
   module Batch
-    VERSION = "0.4.3"
+    VERSION = "0.6.0"
   end
 end

data/lib/graphql/batch.rb

@@ -16,29 +16,21 @@ module GraphQL
     end
 
     def self.use(schema_defn, executor_class: GraphQL::Batch::Executor)
-      # Support 1.10+ which passes the class instead of the definition proxy
-      schema = schema_defn.is_a?(Class) ? schema_defn : schema_defn.target
-      current_gem_version = Gem::Version.new(GraphQL::VERSION)
-      if current_gem_version >= Gem::Version.new("1.6.0")
-        instrumentation = GraphQL::Batch::SetupMultiplex.new(schema, executor_class: executor_class)
+      if schema_defn.respond_to?(:trace_with)
+        schema_defn.trace_with(GraphQL::Batch::SetupMultiplex::Trace, executor_class: executor_class)
+      else
+        instrumentation = GraphQL::Batch::SetupMultiplex.new(schema_defn, executor_class: executor_class)
         schema_defn.instrument(:multiplex, instrumentation)
-        if schema.mutation
-          if current_gem_version >= Gem::Version.new('1.9.0.pre3') &&
-              (schema.mutation.is_a?(Class) || schema.mutation.metadata[:type_class])
-            require_relative "batch/mutation_field_extension"
-            schema.mutation.fields.each do |name, f|
-              field = f.respond_to?(:type_class) ? f.type_class : f.metadata[:type_class]
-              field.extension(GraphQL::Batch::MutationFieldExtension)
-            end
-          else
-            schema_defn.instrument(:field, instrumentation)
-          end
+      end
+
+      if schema_defn.mutation
+        require_relative "batch/mutation_field_extension"
+
+        schema_defn.mutation.fields.each do |name, field|
+          field.extension(GraphQL::Batch::MutationFieldExtension)
         end
-      else
-        instrumentation = GraphQL::Batch::Setup.new(schema, executor_class: executor_class)
-        schema_defn.instrument(:query, instrumentation)
-        schema_defn.instrument(:field, instrumentation)
       end
+
       schema_defn.lazy_resolve(::Promise, :sync)
     end
   end
@@ -47,5 +39,4 @@ end
 require_relative "batch/version"
 require_relative "batch/loader"
 require_relative "batch/executor"
-require_relative "batch/setup"
 require_relative "batch/setup_multiplex"