Merge pull request #52 from richmolj/hooks_clean

Add post-processing hooks

Author: richmolj

lib/jsonapi_compliable/adapters/active_record_sideloading.rb

@@ -39,9 +39,9 @@ def belongs_to(association_name, scope: nil, resource:, foreign_key:, primary_ke
               parent.send(:"#{association_name}=", relevant_child)
             end
           end
-        end
 
-        instance_eval(&blk) if blk
+          instance_eval(&blk) if blk
+        end
       end
 
       def has_one(association_name, scope: nil, resource:, foreign_key:, primary_key: :id, &blk)

lib/jsonapi_compliable/sideload.rb

@@ -191,6 +191,50 @@ def disassociate(parent, child)
       resource.disassociate(parent, child, association_name, type)
     end
 
+    HOOK_ACTIONS = [:save, :create, :update, :destroy, :disassociate]
+
+    # Configure post-processing hooks
+    #
+    # In particular, helpful for bulk operations. "after_save" will fire
+    # for any persistence method - +:create+, +:update+, +:destroy+, +:disassociate+.
+    # Use "only" and "except" keyword arguments to fire only for a
+    # specific persistence method.
+    #
+    # @example Bulk Notify Users on Invite
+    #   class ProjectResource < ApplicationResource
+    #     # ... code ...
+    #     allow_sideload :users, resource: UserResource do
+    #       # scope {}
+    #       # assign {}
+    #       after_save only: [:create] do |project, users|
+    #         UserMailer.invite(project, users).deliver_later
+    #       end
+    #     end
+    #   end
+    #
+    # @see #hooks
+    # @see Util::Persistence
+    def after_save(only: [], except: [], &blk)
+      actions = HOOK_ACTIONS - except
+      actions = only & actions
+      actions = [:save] if only.empty? && except.empty?
+      actions.each do |a|
+        hooks[:"after_#{a}"] << blk
+      end
+    end
+
+    # Get the hooks the user has configured
+    # @see #after_save
+    # @return hash of hooks, ie +{ after_create: #<Proc>}+
+    def hooks
+      @hooks ||= {}.tap do |h|
+        HOOK_ACTIONS.each do |a|
+          h[:"after_#{a}"] = []
+          h[:"before_#{a}"] = []
+        end
+      end
+    end
+
     # Define an attribute that groups the parent records. For instance, with
     # an ActiveRecord polymorphic belongs_to there will be a +parent_id+
     # and +parent_type+. We would want to group on +parent_type+:
@@ -340,6 +384,15 @@ def polymorphic_child_for_type(type)
       end
     end
 
+    def fire_hooks!(parent, objects, method)
+      return unless self.hooks
+
+      hooks = self.hooks[:"after_#{method}"] + self.hooks[:after_save]
+      hooks.compact.each do |hook|
+        resource.instance_exec(parent, objects, &hook)
+      end
+    end
+
     private
 
     def nested_sideload_hash(sideload, processed)

lib/jsonapi_compliable/util/persistence.rb

@@ -27,6 +27,7 @@ def initialize(resource, meta, attributes, relationships, caller_model)
   # * associate parent objects with current object
   # * process children
   # * associate children
+  # * run post-process sideload hooks
   # * return current object
   #
   # @return the persisted model instance
@@ -36,14 +37,17 @@ def run
 
     persisted = persist_object(@meta[:method], @attributes)
     assign_temp_id(persisted, @meta[:temp_id])
+
     associate_parents(persisted, parents)
 
     children = process_has_many(@relationships, persisted) do |x|
       update_foreign_key(persisted, x[:attributes], x)
     end
 
-    associate_children(persisted, children)
-    persisted unless @meta[:method] == :destroy
+    associate_children(persisted, children) unless @meta[:method] == :destroy
+    post_process(persisted, parents)
+    post_process(persisted, children)
+    persisted
   end
 
   private
@@ -76,6 +80,9 @@ def update_foreign_key_for_parents(parents)
   end
 
   def associate_parents(object, parents)
+    # No need to associate to destroyed objects
+    parents = parents.select { |x| x[:meta][:method] != :destroy }
+
     parents.each do |x|
       if x[:object] && object
         if x[:meta][:method] == :disassociate
@@ -88,6 +95,9 @@ def associate_parents(object, parents)
   end
 
   def associate_children(object, children)
+    # No need to associate destroyed objects
+    return if @meta[:method] == :destroy
+
     children.each do |x|
       if x[:object] && object
         if x[:meta][:method] == :disassociate
@@ -131,6 +141,16 @@ def process_belongs_to(relationships)
     end
   end
 
+  def post_process(caller_model, processed)
+    groups = processed.group_by { |x| x[:meta][:method] }
+    groups.each_pair do |method, group|
+      group.group_by { |g| g[:sideload] }.each_pair do |sideload, members|
+        objects = members.map { |x| x[:object] }
+        sideload.fire_hooks!(caller_model, objects, method)
+      end
+    end
+  end
+
   def assign_temp_id(object, temp_id)
     object.instance_variable_set(:@_jsonapi_temp_id, temp_id)
   end

spec/integration/rails/hooks_spec.rb

@@ -0,0 +1,246 @@
+if ENV["APPRAISAL_INITIALIZED"]
+  require 'rails_spec_helper'
+
+  RSpec.describe 'sideload lifecycle hooks', type: :controller do
+    class Callbacks
+      def self.fired
+        @fired
+      end
+
+      def self.fired=(val)
+        @fired = val
+      end
+    end
+
+    before do
+      Callbacks.fired = {}
+    end
+
+    module IntegrationHooks
+      class BookResource < JsonapiCompliable::Resource
+        type :books
+        use_adapter JsonapiCompliable::Adapters::ActiveRecord
+        model Book
+      end
+
+      class StateResource < JsonapiCompliable::Resource
+        type :states
+        use_adapter JsonapiCompliable::Adapters::ActiveRecord
+        model State
+      end
+
+      class AuthorResource < JsonapiCompliable::Resource
+        type :authors
+        use_adapter JsonapiCompliable::Adapters::ActiveRecord
+        model Author
+
+        has_many :books,
+          foreign_key: :author_id,
+          scope: -> { Book.all },
+          resource: BookResource do
+            after_save only: [:create] do |author, books|
+              Callbacks.fired[:after_create] = [author, books]
+            end
+
+            after_save only: [:update] do |author, books|
+              Callbacks.fired[:after_update] = [author, books]
+            end
+
+            after_save only: [:destroy] do |author, books|
+              Callbacks.fired[:after_destroy] = [author, books]
+            end
+
+            after_save only: [:disassociate] do |author, books|
+              Callbacks.fired[:after_disassociate] = [author, books]
+            end
+
+            after_save do |author, books|
+              Callbacks.fired[:after_save] = [author, books]
+            end
+          end
+
+        belongs_to :state,
+          foreign_key: :state_id,
+          scope: -> { State.all },
+          resource: StateResource do
+            after_save only: [:create] do |author, states|
+              Callbacks.fired[:state_after_create] = [author, states]
+            end
+          end
+      end
+    end
+
+    controller(ApplicationController) do
+      jsonapi resource: IntegrationHooks::AuthorResource
+
+      def create
+        author, success = jsonapi_create.to_a
+
+        if success
+          render_jsonapi(author, scope: false)
+        else
+          raise 'whoops'
+        end
+      end
+
+      private
+
+      def params
+        @params ||= begin
+          hash = super.to_unsafe_h.with_indifferent_access
+          hash = hash[:params] if hash.has_key?(:params)
+          hash
+        end
+      end
+    end
+
+    before do
+      @request.headers['Accept'] = Mime[:json]
+      @request.headers['Content-Type'] = Mime[:json].to_s
+
+      routes.draw {
+        post "create" => "anonymous#create"
+      }
+    end
+
+    def json
+      JSON.parse(response.body)
+    end
+
+    let(:update_book) { Book.create! }
+    let(:destroy_book) { Book.create! }
+    let(:disassociate_book) { Book.create! }
+
+    let(:book_data) { [] }
+    let(:book_included) { [] }
+    let(:state_data) { {} }
+    let(:state_included) { [] }
+
+    let(:payload) do
+      {
+        data: {
+          type: 'authors',
+          attributes: { first_name: 'Stephen', last_name: 'King' },
+          relationships: {
+            books: { data: book_data },
+            state: { data: state_data }
+          }
+        },
+        included: (book_included + state_included)
+      }
+    end
+
+    context 'after_save' do
+      before do
+        book_data << { :'temp-id' => 'abc123', type: 'books', method: 'create' }
+        book_included << { :'temp-id' => 'abc123', type: 'books', attributes: { title: 'one' } }
+        book_data << { id: update_book.id.to_s, type: 'books', method: 'update' }
+        book_included << { id: update_book.id.to_s, type: 'books', attributes: { title: 'updated!' } }
+      end
+    end
+
+    context 'after_create' do
+      before do
+        book_data << { :'temp-id' => 'abc123', type: 'books', method: 'create' }
+        book_included << { :'temp-id' => 'abc123', type: 'books', attributes: { title: 'one' } }
+        book_data << { :'temp-id' => 'abc456', type: 'books', method: 'create' }
+        book_included << { :'temp-id' => 'abc456', type: 'books', attributes: { title: 'two' } }
+      end
+
+      it 'fires hooks correctly' do
+        post :create, params: payload
+
+        expect(Callbacks.fired.keys).to match_array([:after_create, :after_save])
+        author, books = Callbacks.fired[:after_create]
+        expect(author).to be_a(Author)
+        expect(author.first_name).to eq('Stephen')
+        expect(author.last_name).to eq('King')
+
+        expect(books).to all(be_a(Book))
+        expect(books.map(&:title)).to match_array(%w(one two))
+      end
+    end
+
+    context 'after_update' do
+      before do
+        book_data << { id: update_book.id.to_s, type: 'books', method: 'update' }
+        book_included << { id: update_book.id.to_s, type: 'books', attributes: { title: 'updated!' } }
+      end
+
+      it 'fires hooks correctly' do
+        post :create, params: payload
+
+        expect(Callbacks.fired.keys)
+          .to match_array([:after_update, :after_save])
+        author, books = Callbacks.fired[:after_update]
+        expect(author).to be_a(Author)
+        expect(author.first_name).to eq('Stephen')
+        expect(author.last_name).to eq('King')
+
+        book = books[0]
+        expect(book.title).to eq('updated!')
+      end
+    end
+
+    context 'after_destroy' do
+      before do
+        book_data << { id: destroy_book.id.to_s, type: 'books', method: 'destroy' }
+      end
+
+      it 'fires hooks correctly' do
+        post :create, params: payload
+
+        expect(Callbacks.fired.keys).to match_array([:after_destroy, :after_save])
+        author, books = Callbacks.fired[:after_destroy]
+        expect(author).to be_a(Author)
+        expect(author.first_name).to eq('Stephen')
+        expect(author.last_name).to eq('King')
+
+        book = books[0]
+        expect(book).to be_a(Book)
+        expect(book.id).to eq(destroy_book.id)
+        expect { book.reload }.to raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+
+    context 'after_disassociate' do
+      before do
+        book_data << { id: disassociate_book.id.to_s, type: 'books', method: 'disassociate' }
+      end
+
+      it 'fires hooks correctly' do
+        post :create, params: payload
+
+        expect(Callbacks.fired.keys).to match_array([:after_disassociate, :after_save])
+        author, books = Callbacks.fired[:after_disassociate]
+        expect(author).to be_a(Author)
+        expect(author.first_name).to eq('Stephen')
+        expect(author.last_name).to eq('King')
+
+        book = books[0]
+        expect(book).to be_a(Book)
+        expect(book.id).to eq(disassociate_book.id)
+        expect(book.author_id).to be_nil
+      end
+    end
+
+    context 'belongs_to' do
+      before do
+        state_data.merge!(:'temp-id' => 'abc123', type: 'states', method: 'create')
+        state_included << { :'temp-id' => 'abc123', type: 'states', attributes: { name: 'New York' } }
+      end
+
+      it 'also works' do
+        post :create, params: payload
+        expect(Callbacks.fired.keys).to match_array([:state_after_create])
+        author, states = Callbacks.fired[:state_after_create]
+        state = states[0]
+        expect(author).to be_a(Author)
+        expect(author.first_name).to eq('Stephen')
+        expect(author.last_name).to eq('King')
+        expect(state).to be_a(State)
+        expect(state.name).to eq('New York')
+      end
+    end
+  end
+end