graphql-batch 0.3.10 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c793255ae48cf638179b9e786d03493a469d1629
-  data.tar.gz: d235b788e4f9208747d7145e7d2599c2279319d1
+SHA256:
+  metadata.gz: c1f52d43c7f189fab24b5e00f8b34435e99c03ae23ba4c99dfaa7a94d67271ed
+  data.tar.gz: 0ceb7b68519b2e1bd0f94686376d26590cebb9697fd50e80272d0770a85c4784
 SHA512:
-  metadata.gz: 7b263790b1871d54d9258e7bd2541c17361b8177a79e07aac146f9d3ccf05570cf07f8aaac40cf4dbe76c3b6f1677f3cd957a32904742c069a133d3906044767
-  data.tar.gz: d00d449a8872286251cc21d555b54be0690002f697dddb8afc1f43e6b90d75e42367ad70f54c701fc75d89b04427b4d127879481c406a24555d3ada35ce0582f
+  metadata.gz: '091fe19e752f10751216374384346e2c4bb0d8fbe35e86248b3584396531ff2775b4732380da5109968b402320ca22e0cc2f1f772ca26f9d12b4b2bfc5a5a049'
+  data.tar.gz: 6890562c5b66004bf10b886ba6370cf7c544ab796f2e29ac279b49c93003079b1722c068155a168f5ee9f3194b34395a2d26ac2e8e3013cecd6e74db2286d8ad

data/.travis.yml

@@ -1,7 +1,7 @@
 language: ruby
 rvm:
-  - 2.1
-  - 2.2
   - 2.3
-  - 2.4
-before_install: gem install bundler -v 1.13.3
+  - 2.6
+env:
+  - TESTING_INTERPRETER=true
+  - TESTING_INTERPRETER=false

data/Gemfile

@@ -1,3 +1,7 @@
 source 'https://rubygems.org'
 
 gemspec
+
+if ENV["TESTING_INTERPRETER"] == "true"
+  gem "graphql", "1.9.0.pre4"
+end

data/README.md

@@ -25,6 +25,8 @@ Or install it yourself as:
 
 ### Basic Usage
 
+#### Schema Configuration
+
 Require the library
 
 ```ruby
@@ -49,8 +51,9 @@ end
 Use `GraphQL::Batch` as a plugin in your schema (for graphql >= `1.5.0`).
 
 ```ruby
-MySchema = GraphQL::Schema.define do
+class MySchema < GraphQL::Schema
   query MyQueryType
+  mutation MyMutationType
 
   use GraphQL::Batch
 end
@@ -66,16 +69,39 @@ MySchema = GraphQL::Schema.define do
 end
 ```
 
-The loader class can be used from the resolve proc 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.
+##### With `1.9.0`'s `Interpreter` runtime
+
+Add `GraphQL::Batch` _after_ the interpreter, so that `GraphQL::Batch` can detect the interpreter and attach the right integrations:
+
+```ruby
+use GraphQL::Execution::Interpreter
+use GraphQL::Batch
+```
+
+#### 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.
 
 ```ruby
-resolve -> (obj, args, context) { RecordLoader.for(Product).load(args["id"]) }
+field :product, Types::Product, null: true do
+  argument :id, ID, required: true
+end
+
+def product(id:)
+  RecordLoader.for(Product).load(id)
+end
 ```
 
 The loader also supports batch loading an array of records instead of just a single record, via `load_many`. For example:
 
 ```ruby
-resolve -> (obj, args, context) { RecordLoader.for(Product).load_many(args["ids"]) }
+field :products, [Types::Product, null: true], null: false do
+  argument :ids, [ID], required: true
+end
+
+def product(ids:)
+  RecordLoader.for(Product).load_many(ids)
+end
 ```
 
 Although this library doesn't have a dependency on active record,
@@ -89,8 +115,8 @@ on records with the same id.
 GraphQL::Batch::Loader#load returns a Promise using the [promise.rb gem](https://rubygems.org/gems/promise.rb) to provide a promise based API, so you can transform the query results using `.then`
 
 ```ruby
-resolve -> (obj, args, context) do
-  RecordLoader.for(Product).load(args["id"]).then do |product|
+def product_title(id:)
+  RecordLoader.for(Product).load(id).then do |product|
     product.title
   end
 end
@@ -99,8 +125,8 @@ end
 You may also need to do another query that depends on the first one to get the result, in which case the query block can return another query.
 
 ```ruby
-resolve -> (obj, args, context) do
-  RecordLoader.for(Product).load(args["id"]).then do |product|
+def product_image(id:)
+  RecordLoader.for(Product).load(id).then do |product|
     RecordLoader.for(Image).load(product.image_id)
   end
 end
@@ -109,7 +135,7 @@ end
 If the second query doesn't depend on the first one, then you can use Promise.all, which allows each query in the group to be batched with other queries.
 
 ```ruby
-resolve -> (obj, args, context) do
+def all_collections
   Promise.all([
     CountLoader.for(Shop, :smart_collections).load(context.shop_id),
     CountLoader.for(Shop, :custom_collections).load(context.shop_id),
@@ -122,8 +148,10 @@ end
 `.then` can optionally take two lambda arguments, the first of which is equivalent to passing a block to `.then`, and the second one handles exceptions.  This can be used to provide a fallback
 
 ```ruby
-resolve -> (obj, args, context) do
+def product(id:)
+  # Try the cache first ...
   CacheLoader.for(Product).load(args["id"]).then(nil, lambda do |exc|
+    # But if there's a connection error, go to the underlying database
     raise exc unless exc.is_a?(Redis::BaseConnectionError)
     logger.warn err.message
     RecordLoader.for(Product).load(args["id"])

data/graphql-batch.gemspec

@@ -18,13 +18,10 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency "graphql", ">= 0.8", "< 2"
+  spec.add_runtime_dependency "graphql", ">= 1.3", "< 2"
   spec.add_runtime_dependency "promise.rb", "~> 0.7.2"
 
-  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 "byebug" if RUBY_ENGINE == 'ruby'
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest"
 end

data/lib/graphql/batch.rb

@@ -1,7 +1,4 @@
 require "graphql"
-if Gem::Version.new(GraphQL::VERSION) < Gem::Version.new("1.3")
-  warn "graphql gem versions less than 1.3 are deprecated for use with graphql-batch, upgrade so lazy_resolve can be used"
-end
 require "promise.rb"
 
 module GraphQL
@@ -20,7 +17,17 @@ module GraphQL
 
     def self.use(schema_defn, executor_class: GraphQL::Batch::Executor)
       schema = schema_defn.target
-      if GraphQL::VERSION >= "1.6.0"
+      if Gem::Version.new(GraphQL::VERSION) >= Gem::Version.new('1.9.0.pre3')
+        require_relative "batch/mutation_field_extension"
+        if schema.mutation
+          schema.mutation.fields.each do |name, f|
+            field = f.metadata[:type_class]
+            field.extension(GraphQL::Batch::MutationFieldExtension)
+          end
+        end
+        instrumentation = GraphQL::Batch::SetupMultiplex.new(schema, executor_class: executor_class)
+        schema_defn.instrument(:multiplex, instrumentation)
+      elsif GraphQL::VERSION >= "1.6.0"
         instrumentation = GraphQL::Batch::SetupMultiplex.new(schema, executor_class: executor_class)
         schema_defn.instrument(:multiplex, instrumentation)
         schema_defn.instrument(:field, instrumentation)
@@ -31,15 +38,11 @@ module GraphQL
       end
       schema_defn.lazy_resolve(::Promise, :sync)
     end
-
-    autoload :ExecutionStrategy, 'graphql/batch/execution_strategy'
-    autoload :MutationExecutionStrategy, 'graphql/batch/mutation_execution_strategy'
   end
 end
 
 require_relative "batch/version"
 require_relative "batch/loader"
 require_relative "batch/executor"
-require_relative "batch/promise"
 require_relative "batch/setup"
 require_relative "batch/setup_multiplex"

data/lib/graphql/batch/loader.rb

@@ -1,8 +1,5 @@
 module GraphQL::Batch
   class Loader
-    NoExecutorError = GraphQL::Batch::NoExecutorError
-    deprecate_constant :NoExecutorError if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.3")
-
     def self.for(*group_args)
       loader_key = loader_key_for(*group_args)
       executor = Executor.current

data/lib/graphql/batch/mutation_field_extension.rb

@@ -0,0 +1,12 @@
+module GraphQL::Batch
+  class MutationFieldExtension < GraphQL::Schema::FieldExtension
+    def resolve(object:, arguments:, **_rest)
+      GraphQL::Batch::Executor.current.clear
+      begin
+        ::Promise.sync(yield(object, arguments))
+      ensure
+        GraphQL::Batch::Executor.current.clear
+      end
+    end
+  end
+end

data/lib/graphql/batch/setup.rb

@@ -23,15 +23,6 @@ module GraphQL::Batch
           }
         end
       end
-
-      def before_query(query)
-        warn "Deprecated graphql-batch setup `instrument(:query, GraphQL::Batch::Setup)`, replace with `use GraphQL::Batch`"
-        start_batching(GraphQL::Batch::Executor)
-      end
-
-      def after_query(query)
-        end_batching
-      end
     end
 
     def initialize(schema, executor_class:)

data/lib/graphql/batch/version.rb

@@ -1,5 +1,5 @@
 module GraphQL
   module Batch
-    VERSION = "0.3.10"
+    VERSION = "0.4.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-batch
 version: !ruby/object:Gem::Version
-  version: 0.3.10
+  version: 0.4.0
 platform: ruby
 authors:
 - Dylan Thacker-Smith
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-22 00:00:00.000000000 Z
+date: 2019-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -16,7 +16,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '1.3'
     - - "<"
       - !ruby/object:Gem::Version
         version: '2'
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '1.3'
     - - "<"
       - !ruby/object:Gem::Version
         version: '2'
@@ -58,20 +58,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.10'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.10'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -120,11 +106,9 @@ files:
 - examples/record_loader.rb
 - graphql-batch.gemspec
 - lib/graphql/batch.rb
-- lib/graphql/batch/execution_strategy.rb
 - lib/graphql/batch/executor.rb
 - lib/graphql/batch/loader.rb
-- lib/graphql/batch/mutation_execution_strategy.rb
-- lib/graphql/batch/promise.rb
+- lib/graphql/batch/mutation_field_extension.rb
 - lib/graphql/batch/setup.rb
 - lib/graphql/batch/setup_multiplex.rb
 - lib/graphql/batch/version.rb
@@ -148,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: A query batching executor for the graphql gem

data/lib/graphql/batch/execution_strategy.rb

@@ -1,67 +0,0 @@
-warn "GraphQL::Batch::ExecutionStrategy is deprecated, instead add `use GraphQL::Batch` in GraphQL::Schema.define"
-
-module GraphQL::Batch
-  class ExecutionStrategy < GraphQL::Query::SerialExecution
-    def execute(_, _, query)
-      GraphQL::Batch.batch do
-        as_promise_unless_resolved(super)
-      end
-    rescue GraphQL::InvalidNullError => err
-      err.parent_error? || query.context.errors.push(err)
-      nil
-    end
-
-    # Needed for MutationExecutionStrategy
-    def deep_sync(result) #:nodoc:
-      ::Promise.sync(as_promise_unless_resolved(result))
-    end
-
-    private
-
-    def as_promise_unless_resolved(result)
-      all_promises = []
-      each_promise(result) do |obj, key, promise|
-        obj[key] = nil
-        all_promises << promise.then do |value|
-          obj[key] = value
-          as_promise_unless_resolved(value)
-        end
-      end
-      return result if all_promises.empty?
-      ::Promise.all(all_promises).then { result }
-    end
-
-    def each_promise(obj, &block)
-      case obj
-      when Array
-        obj.each_with_index do |value, idx|
-          each_promise_in_entry(obj, idx, value, &block)
-        end
-      when Hash
-        obj.each do |key, value|
-          each_promise_in_entry(obj, key, value, &block)
-        end
-      end
-    end
-
-    def each_promise_in_entry(obj, key, value, &block)
-      if value.is_a?(::Promise)
-        yield obj, key, value
-      else
-        each_promise(value, &block)
-      end
-    end
-
-    class FieldResolution < GraphQL::Query::SerialExecution::FieldResolution
-      def get_finished_value(raw_value)
-        if raw_value.is_a?(::Promise)
-          raw_value.then(->(result) { super(result) }, lambda do |error|
-            error.is_a?(GraphQL::ExecutionError) ? super(error) : raise(error)
-          end)
-        else
-          super
-        end
-      end
-    end
-  end
-end

data/lib/graphql/batch/mutation_execution_strategy.rb

@@ -1,23 +0,0 @@
-require_relative "execution_strategy"
-
-module GraphQL::Batch
-  class MutationExecutionStrategy < GraphQL::Batch::ExecutionStrategy
-    attr_accessor :enable_batching
-
-    class FieldResolution < GraphQL::Batch::ExecutionStrategy::FieldResolution
-      def get_finished_value(raw_value)
-        strategy = execution_context.strategy
-        return super if strategy.enable_batching
-
-        GraphQL::Batch::Executor.current.clear
-        begin
-          strategy.enable_batching = true
-          strategy.deep_sync(::Promise.sync(super))
-        ensure
-          strategy.enable_batching = false
-          GraphQL::Batch::Executor.current.clear
-        end
-      end
-    end
-  end
-end

data/lib/graphql/batch/promise.rb

@@ -1,6 +0,0 @@
-module GraphQL::Batch
-  Promise = ::Promise
-  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.3")
-    deprecate_constant :Promise
-  end
-end