Try jsonapi-deserialization

Author: bf4

active_model_serializers.gemspec

@@ -43,6 +43,7 @@ Gem::Specification.new do |spec|
   # 'thread_safe'
 
   spec.add_runtime_dependency 'jsonapi-renderer', ['>= 0.1.1.beta1', '< 0.2']
+  spec.add_runtime_dependency 'jsonapi-deserializable', '~> 0.1.1'
   spec.add_runtime_dependency 'case_transform', '>= 0.2'
 
   spec.add_development_dependency 'activerecord', rails_versions

lib/active_model_serializers/adapter/json_api/deserialization.rb

@@ -1,9 +1,7 @@
+require 'jsonapi/deserializable/resource'
 module ActiveModelSerializers
   module Adapter
     class JsonApi
-      # NOTE(Experimental):
-      # This is an experimental feature. Both the interface and internals could be subject
-      # to changes.
       module Deserialization
         InvalidDocument = Class.new(ArgumentError)
 
@@ -72,72 +70,41 @@ module Deserialization
         #     #   author_type: 'people'
         #     # }
         #
+        # @example
+        #   def deserialized_params
+        #     ActionController::Parameters.new(
+        #       ActiveModelSerializers::Deserialization.jsonapi_parse!(
+        #         request.request_parameters # no need for request.query_parameters, request.path_parameters
+        #       )
+        #     )
+        #   end
         def parse!(document, options = {})
-          parse(document, options) do |invalid_payload, reason|
-            fail InvalidDocument, "Invalid payload (#{reason}): #{invalid_payload}"
+          document = document.dup.permit!.to_h if document.is_a?(ActionController::Parameters)
+          primary_data = document.slice('data')
+          hash = JSONAPI::Deserializable::Resource.call(primary_data)
+          id_keys = hash.keys.select { |key| key.to_s.end_with?('_id') }.map { |key| key.to_s.sub(/_id\z/, '') }
+          ids_keys = hash.keys.select { |key| key.to_s.end_with?('_ids') }.map { |key| key.to_s.sub(/_ids\z/, '') }
+          excluded_keys = id_keys.map { |key| "#{key}_type" } .concat(ids_keys.map { |key| "#{key}_types" })
+          excluded_keys << :type
+          excluded_keys.map!(&:to_sym)
+          hash = hash.except(*excluded_keys)
+          filter_fields(hash, options)
+          transform_keys(hash, options)
+        rescue NoMethodError, JSONAPI::Parser::InvalidDocument => e
+          if block_given?
+            yield(e)
+          else
+            raise InvalidDocument, "Invalid payload (#{e.message}): #{primary_data}"
           end
         end
 
         # Same as parse!, but returns an empty hash instead of raising InvalidDocument
         # on invalid payloads.
         def parse(document, options = {})
-          document = document.dup.permit!.to_h if document.is_a?(ActionController::Parameters)
-
-          validate_payload(document) do |invalid_document, reason|
-            yield invalid_document, reason if block_given?
-            return {}
-          end
-
-          primary_data = document['data']
-          attributes = primary_data['attributes'] || {}
-          attributes['id'] = primary_data['id'] if primary_data['id']
-          relationships = primary_data['relationships'] || {}
-
-          filter_fields(attributes, options)
-          filter_fields(relationships, options)
-
-          hash = {}
-          hash.merge!(parse_attributes(attributes, options))
-          hash.merge!(parse_relationships(relationships, options))
-
-          hash
-        end
-
-        # Checks whether a payload is compliant with the JSON API spec.
-        #
-        # @api private
-        # rubocop:disable Metrics/CyclomaticComplexity
-        def validate_payload(payload)
-          unless payload.is_a?(Hash)
-            yield payload, 'Expected hash'
-            return
-          end
-
-          primary_data = payload['data']
-          unless primary_data.is_a?(Hash)
-            yield payload, { data: 'Expected hash' }
-            return
-          end
-
-          attributes = primary_data['attributes'] || {}
-          unless attributes.is_a?(Hash)
-            yield payload, { data: { attributes: 'Expected hash or nil' } }
-            return
-          end
-
-          relationships = primary_data['relationships'] || {}
-          unless relationships.is_a?(Hash)
-            yield payload, { data: { relationships: 'Expected hash or nil' } }
-            return
-          end
-
-          relationships.each do |(key, value)|
-            unless value.is_a?(Hash) && value.key?('data')
-              yield payload, { data: { relationships: { key => 'Expected hash with :data key' } } }
-            end
+          parse!(document, options) do
+            {}
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         # @api private
         def filter_fields(fields, options)
@@ -148,60 +115,6 @@ def filter_fields(fields, options)
           end
         end
 
-        # @api private
-        def field_key(field, options)
-          (options[:keys] || {}).fetch(field.to_sym, field).to_sym
-        end
-
-        # @api private
-        def parse_attributes(attributes, options)
-          transform_keys(attributes, options)
-            .map { |(k, v)| { field_key(k, options) => v } }
-            .reduce({}, :merge)
-        end
-
-        # Given an association name, and a relationship data attribute, build a hash
-        # mapping the corresponding ActiveRecord attribute to the corresponding value.
-        #
-        # @example
-        #   parse_relationship(:comments, [{ 'id' => '1', 'type' => 'comments' },
-        #                                  { 'id' => '2', 'type' => 'comments' }],
-        #                                 {})
-        #    # => { :comment_ids => ['1', '2'] }
-        #   parse_relationship(:author, { 'id' => '1', 'type' => 'users' }, {})
-        #    # => { :author_id => '1' }
-        #   parse_relationship(:author, nil, {})
-        #    # => { :author_id => nil }
-        # @param [Symbol] assoc_name
-        # @param [Hash] assoc_data
-        # @param [Hash] options
-        # @return [Hash{Symbol, Object}]
-        #
-        # @api private
-        def parse_relationship(assoc_name, assoc_data, options)
-          prefix_key = field_key(assoc_name, options).to_s.singularize
-          hash =
-            if assoc_data.is_a?(Array)
-              { "#{prefix_key}_ids".to_sym => assoc_data.map { |ri| ri['id'] } }
-            else
-              { "#{prefix_key}_id".to_sym => assoc_data ? assoc_data['id'] : nil }
-            end
-
-          polymorphic = (options[:polymorphic] || []).include?(assoc_name.to_sym)
-          if polymorphic
-            hash["#{prefix_key}_type".to_sym] = assoc_data.present? ? assoc_data['type'] : nil
-          end
-
-          hash
-        end
-
-        # @api private
-        def parse_relationships(relationships, options)
-          transform_keys(relationships, options)
-            .map { |(k, v)| parse_relationship(k, v['data'], options) }
-            .reduce({}, :merge)
-        end
-
         # @api private
         def transform_keys(hash, options)
           transform = options[:key_transform] || :underscore