graphql-batch 0.3.4 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c839447dcaacc5db8e6e16d95a30c2fc2db4e899
-  data.tar.gz: ca03f0ee057d56cd2311ef51df54de199baa53ca
+  metadata.gz: 8b725a9f32a436a6e9ee155242dbcff2b576c6b8
+  data.tar.gz: d2e42e370abdd6c28014ca0e10e10ae958854e28
 SHA512:
-  metadata.gz: e5b0461239a98c5aa53924f2c9a721bfe8d3fc7a59ae70d261255ecf3421b574fc44626d55c514b57b403368ca94c7e2714f37ca66cf324fbdc3ca69735ea8fc
-  data.tar.gz: abcf9f692f944ac758fa21d6bcd9929a1ceaa9edf8adb6c9c14e019c4c032445dc532cd564fca0010471b02f32903bbdcb13df4a8bae0adde74958bad11387a3
+  metadata.gz: aee2377e4fa101ddeec55f33a679af48776262a80087c0b9e033e280c49d7a02cd2ae225b15b3f466c242c359d429ec60e03291e5d6ab0f74dcd4044eb7ecac9
+  data.tar.gz: 200b341c757155b9fb23aa87e22cd228dc22bfca8d90c05102ddc54ef806034228472a9fc7d45f329cdc6be3ce1361096e9fa9f4985271ce2f51afc74d3042d1

data/README.md

@@ -72,6 +72,12 @@ The loader class can be used from the resolve proc for a graphql field by callin
 resolve -> (obj, args, context) { RecordLoader.for(Product).load(args["id"]) }
 ```
 
+Although this library doesn't have a dependency on active record,
+the [examples directory](examples) has record and association loaders
+for active record which handles edge cases like type casting ids
+and overriding GraphQL::Batch::Loader#cache_key to load associations
+on records with the same id.
+
 ### Promises
 
 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`

data/examples/association_loader.rb

@@ -0,0 +1,48 @@
+class AssociationLoader < GraphQL::Batch::Loader
+  def self.validate(model, association_name)
+    new(model, association_name)
+    nil
+  end
+
+  def initialize(model, association_name)
+    @model = model
+    @association_name = association_name
+    validate
+  end
+
+  def load(record)
+    raise TypeError, "#{@model} loader can't load association for #{record.class}" unless record.is_a?(@model)
+    return Promise.resolve(read_association(record)) if association_loaded?(record)
+    super
+  end
+
+  # We want to load the associations on all records, even if they have the same id
+  def cache_key(record)
+    record.object_id
+  end
+
+  def perform(records)
+    preload_association(records)
+    records.each { |record| fulfill(record, read_association(record)) }
+  end
+
+  private
+
+  def validate
+    unless @model.reflect_on_association(@association_name)
+      raise ArgumentError, "No association #{@association_name} on #{@model}"
+    end
+  end
+
+  def preload_association(records)
+    ::ActiveRecord::Associations::Preloader.new.preload(records, @association_name)
+  end
+
+  def read_association(record)
+    record.public_send(@association_name)
+  end
+
+  def association_loaded?(record)
+    record.association(@association_name).loaded?
+  end
+end

data/examples/record_loader.rb

@@ -0,0 +1,28 @@
+class RecordLoader < GraphQL::Batch::Loader
+  def initialize(model, column: model.primary_key, where: nil)
+    @model = model
+    @column = column.to_s
+    @column_type = model.type_for_attribute(@column)
+    @where = where
+  end
+
+  def load(key)
+    super(@column_type.cast(key))
+  end
+
+  def perform(keys)
+    query(keys).each do |record|
+      value = @column_type.cast(record.public_send(@column))
+      fulfill(value, record)
+    end
+    keys.each { |key| fulfill(key, nil) unless fulfilled?(key) }
+  end
+
+  private
+
+  def query(keys)
+    scope = @model
+    scope = scope.where(@where) if @where
+    scope.where(@column => keys)
+  end
+end

data/lib/graphql/batch.rb

@@ -20,10 +20,15 @@ module GraphQL
     end
 
     def self.use(schema_defn)
+      schema = schema_defn.target
       if GraphQL::VERSION >= "1.6.0"
-        schema_defn.instrument(:multiplex, GraphQL::Batch::SetupMultiplex)
+        instrumentation = GraphQL::Batch::SetupMultiplex.new(schema)
+        schema_defn.instrument(:multiplex, instrumentation)
+        schema_defn.instrument(:field, instrumentation)
       else
-        schema_defn.instrument(:query, GraphQL::Batch::Setup)
+        instrumentation = GraphQL::Batch::Setup.new(schema)
+        schema_defn.instrument(:query, instrumentation)
+        schema_defn.instrument(:field, instrumentation)
       end
       schema_defn.lazy_resolve(::Promise, :sync)
     end

data/lib/graphql/batch/loader.rb

@@ -58,7 +58,6 @@ module GraphQL::Batch
     # For Promise#sync
     def wait #:nodoc:
       if executor
-        executor.loaders.delete(loader_key)
         executor.resolve(self)
       else
         resolve

data/lib/graphql/batch/mutation_execution_strategy.rb

@@ -9,11 +9,13 @@ module GraphQL::Batch
         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

data/lib/graphql/batch/setup.rb

@@ -1,14 +1,54 @@
 module GraphQL::Batch
-  module Setup
-    extend self
+  class Setup
+    class << self
+      def start_batching
+        raise NestedError if GraphQL::Batch::Executor.current
+        GraphQL::Batch::Executor.current = GraphQL::Batch::Executor.new
+      end
+
+      def end_batching
+        GraphQL::Batch::Executor.current = nil
+      end
+
+      def instrument_field(schema, type, field)
+        return field unless type == schema.mutation
+        old_resolve_proc = field.resolve_proc
+        field.redefine do
+          resolve ->(obj, args, ctx) {
+            GraphQL::Batch::Executor.current.clear
+            begin
+              Promise.sync(old_resolve_proc.call(obj, args, ctx))
+            ensure
+              GraphQL::Batch::Executor.current.clear
+            end
+          }
+        end
+      end
+
+      def before_query(query)
+        warn "Deprecated graphql-batch setup `instrument(:query, GraphQL::Batch::Setup)`, replace with `use GraphQL::Batch`"
+        start_batching
+      end
+
+      def after_query(query)
+        end_batching
+      end
+    end
+
+    def initialize(schema)
+      @schema = schema
+    end
 
     def before_query(query)
-      raise NestedError if GraphQL::Batch::Executor.current
-      GraphQL::Batch::Executor.current = GraphQL::Batch::Executor.new
+      Setup.start_batching
     end
 
     def after_query(query)
-      GraphQL::Batch::Executor.current = nil
+      Setup.end_batching
+    end
+
+    def instrument(type, field)
+      Setup.instrument_field(@schema, type, field)
     end
   end
 end

data/lib/graphql/batch/setup_multiplex.rb

@@ -1,14 +1,19 @@
 module GraphQL::Batch
-  module SetupMultiplex
-    extend self
+  class SetupMultiplex
+    def initialize(schema)
+      @schema = schema
+    end
 
     def before_multiplex(multiplex)
-      raise NestedError if GraphQL::Batch::Executor.current
-      GraphQL::Batch::Executor.current = GraphQL::Batch::Executor.new
+      Setup.start_batching
     end
 
     def after_multiplex(multiplex)
-      GraphQL::Batch::Executor.current = nil
+      Setup.end_batching
+    end
+
+    def instrument(type, field)
+      Setup.instrument_field(@schema, type, field)
     end
   end
 end

data/lib/graphql/batch/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-batch
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.5
 platform: ruby
 authors:
 - Dylan Thacker-Smith
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-08-10 00:00:00.000000000 Z
+date: 2017-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -116,6 +116,8 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- examples/association_loader.rb
+- examples/record_loader.rb
 - graphql-batch.gemspec
 - lib/graphql/batch.rb
 - lib/graphql/batch/execution_strategy.rb