WIP - Deserializer implementation

Gemfile

@@ -3,7 +3,11 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in active_model_serializers.gemspec
 gemspec
 
-gem "minitest"
+group :development do
+  gem "minitest"
+  gem "sqlite3", platform: :ruby
+  gem "activerecord-jdbcsqlite3-adapter", platform: :jruby
+end
 
 version = ENV["RAILS_VERSION"] || "4.2"
 

README.md

@@ -5,8 +5,8 @@
 ActiveModel::Serializer brings convention over configuration to your JSON generation.
 
 AMS does this through two components: **serializers** and **adapters**.
-Serializers describe _which_ attributes and relationships should be serialized.
-Adapters describe _how_ attributes and relationships should be serialized.
+Serializers describe _which_ attributes and relationships should be serialized and deserialized.
+Adapters describe _how_ attributes and relationships should be serialized and deserialized.
 
 By default AMS will use the **Flatten Json Adapter**. But we strongly advise you to use **JsonApi Adapter** that follows 1.0 of the format specified in [jsonapi.org/format](http://jsonapi.org/format).
 Check how to change the adapter in the sections bellow.

lib/active_model/serializer.rb

@@ -14,6 +14,7 @@ class Serializer
 
     class << self
       attr_accessor :_attributes
+      attr_accessor :_params
       attr_accessor :_attributes_keys
       attr_accessor :_urls
       attr_accessor :_cache
@@ -28,16 +29,24 @@ class << self
     def self.inherited(base)
       base._attributes = self._attributes.try(:dup) || []
       base._attributes_keys = self._attributes_keys.try(:dup) || {}
+      base._params = self._attributes.try(:dup) || []
       base._urls = []
+
       serializer_file = File.open(caller.first[/^[^:]+/])
       base._cache_digest = Digest::MD5.hexdigest(serializer_file.read)
       super
     end
 
+    def self.params(*attrs)
+      @_params.concat attrs
+      @_params.uniq!
+    end
+
     def self.attributes(*attrs)
       attrs = attrs.first if attrs.first.class == Array
       @_attributes.concat attrs
       @_attributes.uniq!
+      @_params = @_attributes
 
       attrs.each do |attr|
         define_method attr do
@@ -50,6 +59,7 @@ def self.attribute(attr, options = {})
       key = options.fetch(:key, attr)
       @_attributes_keys[attr] = { key: key } if key != attr
       @_attributes << key unless @_attributes.include?(key)
+      @_params << key unless @_params.include?(key)
 
       unless respond_to?(key, false) || _fragmented.respond_to?(attr)
         define_method key do
@@ -105,7 +115,28 @@ def self.adapter
     end
 
     def self.root_name
-      name.demodulize.underscore.sub(/_serializer$/, '') if name
+      name.demodulize.underscore.sub(/_serialization$/, '') if name
+    end
+
+    def self.sanitize_params(params, whitelist = nil)
+      attrs = @_params
+      assocs = _reflections.map(&:name)
+      forbid_id = false
+      if whitelist
+        assocs &= whitelist
+        attrs &= whitelist
+        forbid_id = !whitelist.include?(:id)
+      end
+      permitted_params = adapter.params_whitelist(attrs, assocs, forbid_id)
+      permitted_key = adapter.root || root_name
+
+      params.require(permitted_key.to_sym).permit(permitted_params)
+    end
+
+    def self.deserialize(params, whitelist = [])
+      whitelist.map! { |x| x.to_sym }
+      sanitized_params = sanitize_params(params, whitelist)
+      adapter.parse(sanitized_params)
     end
 
     attr_accessor :object, :root, :meta, :meta_key, :scope

lib/active_model/serializer/adapter.rb

@@ -9,6 +9,11 @@ class Adapter
       autoload :Null
       autoload :JsonApi
 
+      class << self
+        attr_accessor :root
+        attr_accessor :params
+      end
+
       attr_reader :serializer
 
       def initialize(serializer, options = {})

lib/active_model/serializer/adapter/json_api.rb

@@ -5,9 +5,47 @@ module ActiveModel
   class Serializer
     class Adapter
       class JsonApi < Adapter
+        @root = :data
+        DEFAULT_ATTRIBUTES = [:id, :type]
+
+        def self.params_whitelist(permitted, associations, forbid_id = false)
+          relationships = {}
+          associations.each do |assoc|
+            relationships[assoc] = [ @root, @root => DEFAULT_ATTRIBUTES ]
+          end
+          whitelist = :type, { attributes: permitted }, { relationships: relationships }
+          whitelist << :id unless forbid_id
+
+          whitelist
+        end
+
+        def self.parse(params)
+          attrs, assoc = {}, {}
+          attrs = params['attributes'] if params['attributes']
+          attrs['id'] = params['id'] if params['id']
+          assoc = params['relationships'].map do |rel|
+            key, data = rel.shift.singularize, rel.first['data']
+            key = if data.kind_of? Array
+                    "#{key}_ids"
+                  else
+                    "#{key}_id"
+                  end
+            value = if data.kind_of? Array
+                      data.map { |ri| ri['id'] }
+                    elsif data
+                      data['id']
+                    else
+                      nil
+                    end
+            {key => value}
+          end if params['relationships']
+          assoc.reduce attrs, :merge
+        end
+
         def initialize(serializer, options = {})
           super
-          @hash = { data: [] }
+          @root = self.class.root
+          @hash = { @root => [] }
 
           if fields = options.delete(:fields)
             @fieldset = ActiveModel::Serializer::Fieldset.new(fields, serializer.json_key)
@@ -21,7 +59,7 @@ def serializable_hash(options = nil)
           if serializer.respond_to?(:each)
             serializer.each do |s|
               result = self.class.new(s, @options.merge(fieldset: @fieldset)).serializable_hash(options)
-              @hash[:data] << result[:data]
+              @hash[@root] << result[@root]
 
               if result[:included]
                 @hash[:included] ||= []
@@ -31,8 +69,8 @@ def serializable_hash(options = nil)
 
             add_links(options)
           else
-            @hash[:data] = attributes_for_serializer(serializer, options)
-            add_resource_relationships(@hash[:data], serializer)
+            @hash[@root] = attributes_for_serializer(serializer, options)
+            add_resource_relationships(@hash[@root], serializer)
           end
           @hash
         end
@@ -46,16 +84,17 @@ def fragment_cache(cached_hash, non_cached_hash)
 
         def add_relationships(resource, name, serializers)
           resource[:relationships] ||= {}
-          resource[:relationships][name] ||= { data: [] }
-          resource[:relationships][name][:data] += serializers.map { |serializer| { type: serializer.json_api_type, id: serializer.id.to_s } }
+          resource[:relationships][name] ||= { @root => [] }
+          resource[:relationships][name][@root] ||= []
+          resource[:relationships][name][@root] += serializers.map { |serializer| { type: serializer.json_api_type, id: serializer.id.to_s } }
         end
 
         def add_relationship(resource, name, serializer, val=nil)
           resource[:relationships] ||= {}
-          resource[:relationships][name] = { data: val }
+          resource[:relationships][name] = { @root => val }
 
           if serializer && serializer.object
-            resource[:relationships][name][:data] = { type: serializer.json_api_type, id: serializer.id.to_s }
+            resource[:relationships][name][@root] = { type: serializer.json_api_type, id: serializer.id.to_s }
           end
         end
 

test/action_controller/deserialization_test.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+
+module ActionController
+  module Serializer
+    class ImplicitDeserializerTest < ActionController::TestCase
+      class ImplicitDeserializerTestController < ActionController::Base
+        def create_resource
+          with_adapter :json_api do
+            @post = ARModels::Post.create(create_params)
+            render json: @post, status: :created
+          end
+        end
+
+        private
+
+        def create_params
+          ARModels::PostSerializer.deserialize(params)
+        end
+
+        def with_adapter(adapter)
+          old_adapter = ActiveModel::Serializer.config.adapter
+          # JSON-API adapter sets root by default
+          ActiveModel::Serializer.config.adapter = adapter
+          yield
+        ensure
+          ActiveModel::Serializer.config.adapter = old_adapter
+        end
+      end
+
+      tests ImplicitDeserializerTestController
+
+      def test_json_api_deserialization_on_create
+        payload = {
+          data: {
+            type: 'posts',
+            attributes: {
+              title: 'Title 1',
+              body: 'Body 1'
+            }
+          }
+        }
+
+        post :create_resource, payload
+        new_post = JSON.parse(@response.body)
+
+        assert_equal payload[:data][:attributes][:title], new_post['data']['attributes']['title']
+        assert_equal payload[:data][:attributes][:body], new_post['data']['attributes']['body']
+      end
+
+      def test_json_api_deserialization_on_create_with_associations
+        comment = ARModels::Comment.create(contents: "Comment 1")
+        payload = {
+          data: {
+            type: 'posts',
+            attributes: {
+              title: 'Title 1',
+              body: 'Body 1'
+            },
+            relationships: {
+              comments: {
+                data: [{ id: comment.id, type: 'comments' }]
+              }
+            }
+          }
+        }
+
+        post :create_resource, payload
+        new_post = JSON.parse(@response.body)
+
+        assert_equal 1, new_post['data']['relationships']['comments']['data'].length
+        assert_equal "#{comment.id}", new_post['data']['relationships']['comments']['data'][0]['id']
+        assert_equal 'ar_models_comments', new_post['data']['relationships']['comments']['data'][0]['type']
+      end
+    end
+  end
+end

test/action_controller/serialization_scope_name_test.rb

@@ -60,4 +60,4 @@ def test_override_scope_name_with_controller
     get :render_new_user
     assert_equal '{"data":{"id":"1","type":"users","attributes":{"admin?":true}}}', @response.body
   end
-end
+end

test/adapter/fragment_cache_test.rb

@@ -34,4 +34,3 @@ def test_fragment_fetch_with_namespaced_object
     end
   end
 end
-

test/deserializers/deserialize_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+module ActiveModel
+  class Serializer
+    class DeserializeTest < Minitest::Test
+      def with_adapter(adapter)
+        old_adapter = ActiveModel::Serializer.config.adapter
+        # JSON-API adapter sets root by default
+        ActiveModel::Serializer.config.adapter = adapter
+        yield
+      ensure
+        ActiveModel::Serializer.config.adapter = old_adapter
+      end
+
+      def test_json_api_deserialize_on_create
+        author = ARModels::Author.create(name: "Author 1")
+        comment1 = ARModels::Comment.create(contents: "Comment 1", author: author)
+        comment2 = ARModels::Comment.create(contents: "Comment 2", author: author)
+        payload = {
+          data: {
+            type: 'posts',
+            attributes: {
+              title: 'Title 1',
+              body: 'Body 1'
+            },
+            relationships: {
+              author: {
+                data: { id: author.id, type: 'authors'}
+              },
+              comments: {
+                data: [{ id: comment1.id, type: 'comments'},
+                       { id: comment2.id, type: 'comments'}]
+              }
+            }
+          }
+        }
+
+        post = with_adapter :json_api do
+          ARModels::Post.create(ARModels::PostSerializer.deserialize(ActionController::Parameters.new(payload)))
+        end
+
+        assert_equal('Title 1', post.title)
+        assert_equal('Body 1', post.body)
+        assert_equal(2, post.comments.count)
+        assert_equal('Author 1', post.author.name)
+      end
+    end
+  end
+end