Provide access to underlying model during build/update/save process, closer mirroring rails controller patterns.

Changes:
 - (for creates):
	@resource = MyResource.build(params);
	@resource.data #=> unsaved model with attributes applied
 - (for updates):
	@resource = MyResource.find(params);
	@resource.assign_attributes
	@resource.data #=> unsaved model with attributes applied

Author: jkeen

lib/graphiti/request_validators/validator.rb

@@ -17,7 +17,6 @@ def validate
         return true unless @params.has_key?(:data)
 
         resource = @root_resource
-
         if @params[:data].has_key?(:type)
           if (meta_type = deserialized_payload.meta[:type].try(:to_sym))
             if @root_resource.type != meta_type && @root_resource.polymorphic?

lib/graphiti/resource.rb

@@ -97,6 +97,12 @@ def disassociate(parent, child, association_name, type)
       adapter.disassociate(parent, child, association_name, type)
     end
 
+    def assign_with_relationships(meta, attributes, relationships, caller_model = nil, foreign_key = nil)
+      persistence = Graphiti::Util::Persistence \
+        .new(self, meta, attributes, relationships, caller_model, foreign_key)
+      persistence.assign
+    end
+
     def persist_with_relationships(meta, attributes, relationships, caller_model = nil, foreign_key = nil)
       persistence = Graphiti::Util::Persistence \
         .new(self, meta, attributes, relationships, caller_model, foreign_key)

lib/graphiti/resource/interface.rb

@@ -49,7 +49,9 @@ def _find(params = {}, base_scope = nil)
         def build(params, base_scope = nil)
           validate_request!(params)
           runner = Runner.new(self, params)
-          runner.proxy(base_scope, single: true, raise_on_missing: true)
+          runner.proxy(base_scope, single: true, raise_on_missing: true).tap do |instance|
+            instance.assign_attributes # assign the params to the underlying model
+          end
         end
 
         private

lib/graphiti/resource/persistence.rb

@@ -69,6 +69,24 @@ def add_callback(kind, lifecycle, method, only, &blk)
         end
       end
 
+      def assign(assign_params, meta = nil)
+        id = assign_params[:id]
+        assign_params = assign_params.except(:id)
+        model_instance = nil
+
+        run_callbacks :attributes, :assign, assign_params, meta do |params|
+          model_instance = if meta[:method] == :update && id
+                             self.class._find(id: id).data
+                           else
+                             call_with_meta(:build, model, meta)
+                           end
+          call_with_meta(:assign_attributes, model_instance, params, meta)
+          model_instance
+        end
+
+        model_instance
+      end
+
       def create(create_params, meta = nil)
         model_instance = nil
 

lib/graphiti/resource_proxy.rb

@@ -117,6 +117,16 @@ def pagination
       @pagination ||= Delegates::Pagination.new(self)
     end
 
+    def assign_attributes(params = nil)
+      # deserialize params again?
+
+      @data = @resource.assign_with_relationships(
+        @payload.meta,
+        @payload.attributes,
+        @payload.relationships,
+      )
+    end
+
     def save(action: :create)
       # TODO: remove this. Only used for persisting many-to-many with AR
       # (see activerecord adapter)
@@ -167,6 +177,7 @@ def destroy
 
     def update
       resolve_data
+      assign_attributes
       save(action: :update)
     end
 

lib/graphiti/runner.rb

@@ -8,7 +8,6 @@ def initialize(resource_class, params, query = nil, action = nil)
       @params = params
       @query = query
       @action = action
-
       validator = RequestValidator.new(jsonapi_resource, params, action)
       validator.validate!
 

lib/graphiti/util/persistence.rb

@@ -24,6 +24,14 @@ def initialize(resource, meta, attributes, relationships, caller_model, foreign_
     end
   end
 
+  def assign
+    attributes = @adapter.persistence_attributes(self, @attributes)
+    @assigned = call_resource_method(:assign, attributes, @caller_model)
+    @resource.decorate_record(@assigned)
+
+    @assigned
+  end
+
   # Perform the actual save logic.
   #
   # belongs_to must be processed before/separately from has_many -
@@ -49,8 +57,10 @@ def run
     parents = @adapter.process_belongs_to(self, attributes)
     persisted = persist_object(@meta[:method], attributes)
     @resource.decorate_record(persisted)
-    assign_temp_id(persisted, @meta[:temp_id])
 
+    return persisted if @meta[:method] == :assign
+
+    assign_temp_id(persisted, @meta[:temp_id])
     associate_parents(persisted, parents)
 
     children = @adapter.process_has_many(self, persisted)
@@ -129,6 +139,8 @@ def associate_children(object, children)
 
   def persist_object(method, attributes)
     case method
+      when :assign
+        call_resource_method(:assign, attributes, @caller_model)
       when :destroy
         call_resource_method(:destroy, attributes[:id], @caller_model)
       when :update, nil, :disassociate

spec/integration/rails/callbacks_spec.rb

@@ -8,6 +8,7 @@
 
       routes.draw do
         post "create" => "anonymous#create"
+        put "update" => "anonymous#update"
         delete "destroy" => "anonymous#destroy"
       end
 
@@ -34,6 +35,7 @@ class ApplicationResource < Graphiti::Resource
 
       class EmployeeResource < ApplicationResource
         self.model = Employee
+        self.type= "employees"
 
         before_attributes :one
         before_attributes :two
@@ -168,6 +170,18 @@ def create
         end
       end
 
+      def update
+        employee = IntegrationCallbacks::EmployeeResource._find(params)
+        Thread.current[:proxy] = employee
+        employee.assign_attributes
+
+        if employee.update_attributes
+          render jsonapi: employee
+        else
+          raise "whoops"
+        end
+      end
+
       def destroy
         employee = IntegrationCallbacks::EmployeeResource._find(params)
         Thread.current[:proxy] = employee
@@ -194,7 +208,7 @@ def params
       {
         data: {
           type: "employees",
-          attributes: {first_name: "Jane"}
+          attributes: { first_name: "Jane"}
         }
       }
     end
@@ -227,6 +241,41 @@ def params
         end
       end
 
+      describe "update callbacks" do
+        let!(:employee) { Employee.create!(first_name: "asdf") }
+        let(:payload) {
+          { id: employee.id, 
+              data: {
+                id: employee.id,
+                type: 'employees',
+                attributes: { first_name: "Jane" }
+              }
+            }
+        }
+
+
+        it "fires hooks in order" do
+          expect {
+            put :update, params: payload
+          }.to change { Employee.find(employee.id).first_name }
+          employee = proxy.data
+          expect(employee.first_name)
+            .to eq("Jane5a6a7a12347b6b5b_12a_13a_14a89_10_11_14b_13b_12b")
+        end
+
+        context "when an error is raised" do
+          before do
+            $raise = true
+          end
+
+          it "rolls back the transaction" do
+            expect {
+              expect { put :update, params: payload }.to raise_error("test")
+            }.to_not(change { Employee.count })
+          end
+        end
+      end
+
       describe "destroy callbacks" do
         let!(:employee) { Employee.create!(first_name: "Jane") }
 

spec/persistence_spec.rb

@@ -37,6 +37,22 @@ def expect_errors(object, expected)
     expect(employee.data.first_name).to eq("Jane")
   end
 
+  it "can access the unsaved model after build" do
+    employee = klass.build(payload)
+    expect(employee.data).to_not be_nil
+    expect(employee.data.first_name).to eq("Jane")
+    expect(employee.data.id).to be_nil
+  end
+
+  xit "can modify attributes directly on the unsaved model before save" do
+    employee = klass.build(payload)
+    expect(employee.data).to_not be_nil
+    employee.data.first_name = "June"
+
+    expect(employee.save).to eq(true)
+    expect(employee.data.first_name).to eq("June")
+  end
+
   describe "updating" do
     let!(:employee) { PORO::Employee.create(first_name: "asdf") }
 
@@ -52,6 +68,16 @@ def expect_errors(object, expected)
         }.to raise_error(Graphiti::Errors::RecordNotFound)
       end
     end
+
+    it "can apply attributes and access model" do
+      employee = klass.find(payload)
+      expect(employee.data.first_name).to eq("asdf")
+      employee.assign_attributes
+      expect(employee.data.first_name).to eq("Jane")
+
+      employee = klass.find(payload)
+      expect(employee.data.first_name).to eq("asdf")
+    end
   end
 
   describe "destroying" do
@@ -1825,8 +1851,8 @@ def delete(model, meta)
 
     context "and it is a create operation" do
       it "works" do
-        instance = klass.build(payload)
         expect {
+          instance = klass.build(payload)
           instance.save
         }.to raise_error(Graphiti::Errors::InvalidRequest, /data.attributes.id/)
       end

spec/support/rails/employee_controller.rb

@@ -15,7 +15,7 @@ def create
 
   def update
     employee = resource.find(params)
-
+    
     if employee.update_attributes
       render jsonapi: employee
     else