graphql-batch 0.3.5 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b725a9f32a436a6e9ee155242dbcff2b576c6b8
-  data.tar.gz: d2e42e370abdd6c28014ca0e10e10ae958854e28
+  metadata.gz: d459ffa3cad4df54bc36547ef5dcc0b6f3ecf8fd
+  data.tar.gz: e166361d06b235a13e34c843d682d1153124b1c4
 SHA512:
-  metadata.gz: aee2377e4fa101ddeec55f33a679af48776262a80087c0b9e033e280c49d7a02cd2ae225b15b3f466c242c359d429ec60e03291e5d6ab0f74dcd4044eb7ecac9
-  data.tar.gz: 200b341c757155b9fb23aa87e22cd228dc22bfca8d90c05102ddc54ef806034228472a9fc7d45f329cdc6be3ce1361096e9fa9f4985271ce2f51afc74d3042d1
+  metadata.gz: f00c79b9623279179dbf000d54f1133ed0b65a73757f9c469c3643d6d64cf06139017e0eb919797368eb2f10fef252f0d4b9a1285202dce37ab0c8e767c4e3c6
+  data.tar.gz: b3bd7dcf7ce3d4a653f5bc46dc4ea0a4a53774be63124c7a4d94211a5af8912ef44f3801576750d7408f77422cebde292ddc1b9a02b4ad4853fb3eb6fc2be907

data/.travis.yml

@@ -2,4 +2,6 @@ language: ruby
 rvm:
   - 2.1
   - 2.2
+  - 2.3
+  - 2.4
 before_install: gem install bundler -v 1.13.3

data/examples/record_loader.rb

@@ -11,10 +11,7 @@ class RecordLoader < GraphQL::Batch::Loader
   end
 
   def perform(keys)
-    query(keys).each do |record|
-      value = @column_type.cast(record.public_send(@column))
-      fulfill(value, record)
-    end
+    query(keys).each { |record| fulfill(record.public_send(@column), record) }
     keys.each { |key| fulfill(key, nil) unless fulfilled?(key) }
   end
 

data/graphql-batch.gemspec

@@ -21,7 +21,9 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "graphql", ">= 0.8", "< 2"
   spec.add_runtime_dependency "promise.rb", "~> 0.7.2"
 
-  spec.add_development_dependency "byebug" if RUBY_ENGINE == 'ruby'
+  if RUBY_ENGINE == 'ruby' && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.2")
+    spec.add_development_dependency "byebug"
+  end
   spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest"

data/lib/graphql/batch.rb

@@ -13,20 +13,20 @@ module GraphQL
       raise NestedError if GraphQL::Batch::Executor.current
       begin
         GraphQL::Batch::Executor.current = GraphQL::Batch::Executor.new
-        Promise.sync(yield)
+        ::Promise.sync(yield)
       ensure
         GraphQL::Batch::Executor.current = nil
       end
     end
 
-    def self.use(schema_defn)
+    def self.use(schema_defn, executor_class: GraphQL::Batch::Executor)
       schema = schema_defn.target
       if GraphQL::VERSION >= "1.6.0"
-        instrumentation = GraphQL::Batch::SetupMultiplex.new(schema)
+        instrumentation = GraphQL::Batch::SetupMultiplex.new(schema, executor_class: executor_class)
         schema_defn.instrument(:multiplex, instrumentation)
         schema_defn.instrument(:field, instrumentation)
       else
-        instrumentation = GraphQL::Batch::Setup.new(schema)
+        instrumentation = GraphQL::Batch::Setup.new(schema, executor_class: executor_class)
         schema_defn.instrument(:query, instrumentation)
         schema_defn.instrument(:field, instrumentation)
       end

data/lib/graphql/batch/execution_strategy.rb

@@ -13,7 +13,7 @@ module GraphQL::Batch
 
     # Needed for MutationExecutionStrategy
     def deep_sync(result) #:nodoc:
-      Promise.sync(as_promise_unless_resolved(result))
+      ::Promise.sync(as_promise_unless_resolved(result))
     end
 
     private

data/lib/graphql/batch/executor.rb

@@ -11,8 +11,6 @@ module GraphQL::Batch
       Thread.current[THREAD_KEY] = executor
     end
 
-    attr_reader :loaders
-
     # Set to true when performing a batch query, otherwise, it is false.
     #
     # Can be used to detect unbatched queries in an ActiveSupport::Notifications.subscribe block.
@@ -23,42 +21,41 @@ module GraphQL::Batch
       @loading = false
     end
 
-    def resolve(loader)
-      with_loading(true) { loader.resolve }
+    def loader(key)
+      @loaders[key] ||= yield.tap do |loader|
+        loader.executor = self
+        loader.loader_key = key
+      end
     end
 
-    def shift
-      @loaders.shift.last
+    def resolve(loader)
+      was_loading = @loading
+      @loading = true
+      loader.resolve
+    ensure
+      @loading = was_loading
     end
 
     def tick
-      resolve(shift)
+      resolve(@loaders.shift.last)
     end
 
     def wait_all
-      tick until loaders.empty?
+      tick until @loaders.empty?
     end
 
     def clear
-      loaders.clear
+      @loaders.clear
     end
 
-    def defer
-      # Since we aren't actually deferring callbacks, we need to set #loading to false so that any queries
-      # that happen in the callback aren't interpreted as being performed in GraphQL::Batch::Loader#perform
-      with_loading(false) { yield }
-    end
-
-    private
-
-    def with_loading(loading)
+    def around_promise_callbacks
+      # We need to set #loading to false so that any queries that happen in the promise
+      # callback aren't interpreted as being performed in GraphQL::Batch::Loader#perform
       was_loading = @loading
-      begin
-        @loading = loading
-        yield
-      ensure
-        @loading = was_loading
-      end
+      @loading = false
+      yield
+    ensure
+      @loading = was_loading
     end
   end
 end

data/lib/graphql/batch/loader.rb

@@ -12,10 +12,7 @@ module GraphQL::Batch
           " `GraphQL::Batch::Setup` as a query instrumenter if using with `graphql-ruby`"
       end
 
-      executor.loaders[loader_key] ||= new(*group_args).tap do |loader|
-        loader.loader_key = loader_key
-        loader.executor = executor
-      end
+      executor.loader(loader_key) { new(*group_args) }
     end
 
     def self.loader_key_for(*group_args)
@@ -35,7 +32,7 @@ module GraphQL::Batch
     def load(key)
       cache[cache_key(key)] ||= begin
         queue << key
-        Promise.new.tap { |promise| promise.source = self }
+        ::Promise.new.tap { |promise| promise.source = self }
       end
     end
 
@@ -50,9 +47,7 @@ module GraphQL::Batch
       perform(load_keys)
       check_for_broken_promises(load_keys)
     rescue => err
-      each_pending_promise(load_keys) do |key, promise|
-        promise.reject(err)
-      end
+      reject_pending_promises
     end
 
     # For Promise#sync
@@ -72,7 +67,15 @@ module GraphQL::Batch
 
     # Fulfill the key with provided value, for use in #perform
     def fulfill(key, value)
-      promise_for(key).fulfill(value)
+      finish_resolve(key) do |promise|
+        promise.fulfill(value)
+      end
+    end
+
+    def reject(key, reason)
+      finish_resolve(key) do |promise|
+        promise.reject(reason)
+      end
     end
 
     # Returns true when the key has already been fulfilled, otherwise returns false
@@ -92,6 +95,14 @@ module GraphQL::Batch
 
     private
 
+    def finish_resolve(key)
+      promise = promise_for(key)
+      return yield(promise) unless executor
+      executor.around_promise_callbacks do
+        yield promise
+      end
+    end
+
     def cache
       @cache ||= {}
     end
@@ -104,18 +115,16 @@ module GraphQL::Batch
       cache.fetch(cache_key(load_key))
     end
 
-    def each_pending_promise(load_keys)
+    def reject_pending_promises
       load_keys.each do |key|
-        promise = promise_for(key)
-        if promise.pending?
-          yield key, promise
-        end
+        # promise.rb ignores reject if promise isn't pending
+        reject(key, err)
       end
     end
 
     def check_for_broken_promises(load_keys)
-      each_pending_promise(load_keys) do |key, promise|
-        promise.reject(::Promise::BrokenError.new("#{self.class} didn't fulfill promise for key #{key.inspect}"))
+      load_keys.each do |key|
+        reject(key, ::Promise::BrokenError.new("#{self.class} didn't fulfill promise for key #{key.inspect}"))
       end
     end
   end

data/lib/graphql/batch/mutation_execution_strategy.rb

@@ -12,7 +12,7 @@ module GraphQL::Batch
         GraphQL::Batch::Executor.current.clear
         begin
           strategy.enable_batching = true
-          strategy.deep_sync(Promise.sync(super))
+          strategy.deep_sync(::Promise.sync(super))
         ensure
           strategy.enable_batching = false
           GraphQL::Batch::Executor.current.clear

data/lib/graphql/batch/promise.rb

@@ -1,8 +1,6 @@
 module GraphQL::Batch
-  class Promise < ::Promise
-    def defer
-      executor = Executor.current
-      executor ? executor.defer { super } : super
-    end
+  Promise = ::Promise
+  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.3")
+    deprecate_constant :Promise
   end
 end

data/lib/graphql/batch/setup.rb

@@ -1,9 +1,9 @@
 module GraphQL::Batch
   class Setup
     class << self
-      def start_batching
+      def start_batching(executor_class)
         raise NestedError if GraphQL::Batch::Executor.current
-        GraphQL::Batch::Executor.current = GraphQL::Batch::Executor.new
+        GraphQL::Batch::Executor.current = executor_class.new
       end
 
       def end_batching
@@ -17,7 +17,7 @@ module GraphQL::Batch
           resolve ->(obj, args, ctx) {
             GraphQL::Batch::Executor.current.clear
             begin
-              Promise.sync(old_resolve_proc.call(obj, args, ctx))
+              ::Promise.sync(old_resolve_proc.call(obj, args, ctx))
             ensure
               GraphQL::Batch::Executor.current.clear
             end
@@ -27,7 +27,7 @@ module GraphQL::Batch
 
       def before_query(query)
         warn "Deprecated graphql-batch setup `instrument(:query, GraphQL::Batch::Setup)`, replace with `use GraphQL::Batch`"
-        start_batching
+        start_batching(GraphQL::Batch::Executor)
       end
 
       def after_query(query)
@@ -35,12 +35,13 @@ module GraphQL::Batch
       end
     end
 
-    def initialize(schema)
+    def initialize(schema, executor_class:)
       @schema = schema
+      @executor_class = executor_class
     end
 
     def before_query(query)
-      Setup.start_batching
+      Setup.start_batching(@executor_class)
     end
 
     def after_query(query)

data/lib/graphql/batch/setup_multiplex.rb

@@ -1,11 +1,12 @@
 module GraphQL::Batch
   class SetupMultiplex
-    def initialize(schema)
+    def initialize(schema, executor_class:)
       @schema = schema
+      @executor_class = executor_class
     end
 
     def before_multiplex(multiplex)
-      Setup.start_batching
+      Setup.start_batching(@executor_class)
     end
 
     def after_multiplex(multiplex)

data/lib/graphql/batch/version.rb

@@ -1,5 +1,5 @@
 module GraphQL
   module Batch
-    VERSION = "0.3.5"
+    VERSION = "0.3.7"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-batch
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.7
 platform: ruby
 authors:
 - Dylan Thacker-Smith
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-08-28 00:00:00.000000000 Z
+date: 2017-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -148,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.5.2.1
 signing_key: 
 specification_version: 4
 summary: A query batching executor for the graphql gem