Merge pull request #95 from wadetandy/after_commit_hook

Add after_commit hooks to resources

Author: wadetandy

lib/graphiti.rb

@@ -61,7 +61,7 @@
 require "graphiti/util/persistence"
 require "graphiti/util/validation_response"
 require "graphiti/util/sideload"
-require "graphiti/util/hooks"
+require "graphiti/util/transaction_hooks_recorder"
 require "graphiti/util/attribute_check"
 require "graphiti/util/serializer_attributes"
 require "graphiti/util/serializer_relationships"

lib/graphiti/resource.rb

@@ -121,14 +121,21 @@ def before_commit(model, metadata)
       end
     end
 
+    def after_commit(model, metadata)
+      hooks = self.class.config[:after_commit][metadata[:method]] || []
+      hooks.each do |hook|
+        instance_exec(model, metadata, &hook)
+      end
+    end
+
     def transaction
       response = nil
       begin
         adapter.transaction(model) do
           response = yield
         end
       rescue Errors::ValidationError => e
-        response = e.validation_response
+        response = { result: e.validation_response }
       end
       response
     end

lib/graphiti/resource/configuration.rb

@@ -181,6 +181,7 @@ def config
               sorts: {},
               pagination: nil,
               before_commit: {},
+              after_commit: {},
               attributes: {},
               extra_attributes: {},
               sideloads: {},

lib/graphiti/resource/dsl.rb

@@ -87,6 +87,13 @@ def before_commit(only: [:create, :update, :destroy], &blk)
           end
         end
 
+        def after_commit(only: [:create, :update, :destroy], &blk)
+          Array(only).each do |verb|
+            config[:after_commit][verb] ||= []
+            config[:after_commit][verb] << blk
+          end
+        end
+
         def attribute(name, type, options = {}, &blk)
           raise Errors::TypeNotFound.new(self, name, type) unless Types[type]
           attribute_option(options, :readable)

lib/graphiti/resource_proxy.rb

@@ -114,17 +114,18 @@ def save(action: :create)
     end
 
     def destroy
-      validator = @resource.transaction do
+      transaction_response = @resource.transaction do
         metadata = { method: :destroy }
         model = @resource.destroy(@query.filters[:id], metadata)
         model.instance_variable_set(:@__serializer_klass, @resource.serializer)
         validator = ::Graphiti::Util::ValidationResponse.new \
           model, @payload
         validator.validate!
         @resource.before_commit(model, metadata)
-        validator
+
+        { result: validator }
       end
-      @data, success = validator.to_a
+      @data, success = transaction_response[:result].to_a
       success
     end
 
@@ -154,15 +155,24 @@ def debug_requested?
     private
 
     def persist
-      @resource.transaction do
-        ::Graphiti::Util::Hooks.record do
+      transaction_response = @resource.transaction do
+        ::Graphiti::Util::TransactionHooksRecorder.record do
           model = yield
           validator = ::Graphiti::Util::ValidationResponse.new \
             model, @payload
           validator.validate!
           validator
         end
       end
+
+      data, success = transaction_response[:result].to_a
+      if success
+        transaction_response[:after_commit_hooks].each do |hook|
+          hook.call
+        end
+      end
+
+      transaction_response[:result]
     end
   end
 end

lib/graphiti/util/hooks.rb

@@ -63,7 +63,9 @@ def run
     post_process(persisted, parents)
     post_process(persisted, children)
     before_commit = -> { @resource.before_commit(persisted, metadata) }
-    add_hook(before_commit)
+    add_hook(before_commit, :before_commit)
+    after_commit = -> { @resource.after_commit(persisted, metadata) }
+    add_hook(after_commit, :after_commit)
     persisted
   end
 
@@ -83,8 +85,8 @@ def typecast_attributes
     end
   end
 
-  def add_hook(prc)
-    ::Graphiti::Util::Hooks.add(prc)
+  def add_hook(prc, lifecycle_event)
+    ::Graphiti::Util::TransactionHooksRecorder.add(prc, lifecycle_event)
   end
 
   # The child's attributes should be modified to nil-out the
@@ -215,7 +217,7 @@ def post_process(caller_model, processed)
       group.group_by { |g| g[:sideload] }.each_pair do |sideload, members|
         objects = members.map { |x| x[:object] }
         hook = -> { sideload.fire_hooks!(caller_model, objects, method) }
-        add_hook(hook)
+        add_hook(hook, :before_commit)
       end
     end
   end

lib/graphiti/util/persistence.rb

@@ -0,0 +1,72 @@
+module Graphiti
+  module Util
+    class TransactionHooksRecorder
+      # This is a thread-global singleton class which is used to capture
+      # the correct hooks to run when before and after transactions are
+      # committed.  Consuming code will call the #record method, which will
+      # yield to the passed block:
+      #
+      # ```ruby
+      # TransactionHooksRecorder.record do
+      #   TransactionHooksRecorder.add(->{ do_stuff() }, :before_commit)
+      #   TransactionHooksRecorder.add(->{ do_more_stuff() }, :after_commit)
+      #   {
+      #     result: do_the_main_thing_and_return_a_result()
+      #   }
+      # end
+      # ```
+      #
+      # before_commit hooks will be executed before the record method returns.
+      # All after_commit hooks will be added to the returned hash so that consumers
+      # can decide when and whether to execute the callbacks.
+      #
+      # Returns a hash with `result` and `after_commit_hooks` keys.
+      class << self
+        def record
+          reset_hooks
+
+          begin
+            result = yield
+            run(:before_commit)
+
+            unless result.kind_of?(::Hash)
+              result = { result: result }
+            end
+
+            result.tap do |r|
+              r[:after_commit_hooks] = hook_set(:after_commit)
+            end
+          ensure
+            reset_hooks
+          end
+        end
+
+        # Because hooks will be added from the outer edges of
+        # the graph, working inwards
+        def add(prc, lifecycle_event)
+          hook_set(lifecycle_event).unshift(prc)
+        end
+
+        def run(lifecycle_event)
+          _hooks[lifecycle_event].each { |h| h.call }
+        end
+
+        private
+        def _hooks
+          Thread.current[:_graphiti_hooks]
+        end
+
+        def reset_hooks
+          Thread.current[:_graphiti_hooks] = {
+            before_commit: [],
+            after_commit: [],
+          }
+        end
+
+        def hook_set(lifecycle_event)
+          _hooks[lifecycle_event]
+        end
+      end
+    end
+  end
+end

lib/graphiti/util/transaction_hooks_recorder.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "1.0.rc.19"
+  VERSION = "1.0.rc.20"
 end