diff --git a/README.md b/README.md index 057c8bd..b86e4ef 100644 --- a/README.md +++ b/README.md @@ -221,7 +221,7 @@ end ``` ### Links Per Object -Links are defined in FastJsonapi using the `link` method. By default, link are read directly from the model property of the same name.In this example, `public_url` is expected to be a property of the object being serialized. +Links are defined in FastJsonapi using the `link` method. By default, link are read directly from the model property of the same name. In this example, `public_url` is expected to be a property of the object being serialized. You can configure the method to use on the object for example a link with key `self` will get set to the value returned by a method called `url` on the movie object. @@ -449,6 +449,7 @@ serializer.serializable_hash Option | Purpose | Example ------------ | ------------- | ------------- set_type | Type name of Object | ```set_type :movie ``` +key | Key of Object | ```belongs_to :owner, key: :user ``` set_id | ID of Object | ```set_id :owner_id ``` cache_options | Hash to enable caching and set cache length | ```cache_options enabled: true, cache_length: 12.hours, race_condition_ttl: 10.seconds``` id_method_name | Set custom method name to get ID of an object | ```has_many :locations, id_method_name: :place_ids ``` diff --git a/lib/fast_jsonapi/object_serializer.rb b/lib/fast_jsonapi/object_serializer.rb index 71f64bc..c449682 100644 --- a/lib/fast_jsonapi/object_serializer.rb +++ b/lib/fast_jsonapi/object_serializer.rb @@ -1,6 +1,6 @@ # frozen_string_literal: true -require 'active_support/core_ext/object' +require 'active_support/json' require 'active_support/concern' require 'active_support/inflector' require 'fast_jsonapi/attribute' @@ -65,7 +65,7 @@ module FastJsonapi end def serialized_json - self.class.to_json(serializable_hash) + ActiveSupport::JSON.encode(serializable_hash) end private @@ -143,7 +143,11 @@ module FastJsonapi self.transform_method = mapping[transform_name.to_sym] # ensure that the record type is correctly transformed - set_type(reflected_record_type) if reflected_record_type + if record_type + set_type(record_type) + elsif reflected_record_type + set_type(reflected_record_type) + end end def run_key_transform(input) @@ -250,6 +254,7 @@ module FastJsonapi cached: options[:cached], polymorphic: fetch_polymorphic_option(options), conditional_proc: options[:if], + transform_method: @transform_method, links: options[:links], lazy_load_data: options[:lazy_load_data] ) @@ -294,10 +299,10 @@ module FastJsonapi includes.detect do |include_item| klass = self parse_include_item(include_item).each do |parsed_include| - relationship_to_include = klass.relationships_to_serialize[parsed_include] + relationships_to_serialize = klass.relationships_to_serialize || {} + relationship_to_include = relationships_to_serialize[parsed_include] raise ArgumentError, "#{parsed_include} is not specified as a relationship on #{klass.name}" unless relationship_to_include - raise NotImplementedError if relationship_to_include.polymorphic.is_a?(Hash) - klass = relationship_to_include.serializer.to_s.constantize + klass = relationship_to_include.serializer.to_s.constantize unless relationship_to_include.polymorphic.is_a?(Hash) end end end diff --git a/lib/fast_jsonapi/relationship.rb b/lib/fast_jsonapi/relationship.rb index e8163a6..7a038de 100644 --- a/lib/fast_jsonapi/relationship.rb +++ b/lib/fast_jsonapi/relationship.rb @@ -1,6 +1,6 @@ module FastJsonapi class Relationship - attr_reader :key, :name, :id_method_name, :record_type, :object_method_name, :object_block, :serializer, :relationship_type, :cached, :polymorphic, :conditional_proc, :links, :lazy_load_data + attr_reader :key, :name, :id_method_name, :record_type, :object_method_name, :object_block, :serializer, :relationship_type, :cached, :polymorphic, :conditional_proc, :transform_method, :links, :lazy_load_data def initialize( key:, @@ -14,6 +14,7 @@ module FastJsonapi cached: false, polymorphic:, conditional_proc:, + transform_method:, links:, lazy_load_data: false ) @@ -28,6 +29,7 @@ module FastJsonapi @cached = cached @polymorphic = polymorphic @conditional_proc = conditional_proc + @transform_method = transform_method @links = links || {} @lazy_load_data = lazy_load_data end @@ -75,7 +77,7 @@ module FastJsonapi def id_hash_from_record(record, record_types) # memoize the record type within the record_types dictionary, then assigning to record_type: - associated_record_type = record_types[record.class] ||= record.class.name.underscore.to_sym + associated_record_type = record_types[record.class] ||= run_key_transform(record.class.name.demodulize.underscore) id_hash(record.id, associated_record_type) end @@ -103,8 +105,16 @@ module FastJsonapi def add_links_hash(record, params, output_hash) output_hash[key][:links] = links.each_with_object({}) do |(key, method), hash| - Link.new(key: key, method: method).serialize(record, params, hash) + Link.new(key: key, method: method).serialize(record, params, hash)\ + end + end + + def run_key_transform(input) + if self.transform_method.present? + input.to_s.send(*self.transform_method).to_sym + else + input.to_sym end end end -end \ No newline at end of file +end diff --git a/lib/fast_jsonapi/serialization_core.rb b/lib/fast_jsonapi/serialization_core.rb index 8598fe0..a456b21 100644 --- a/lib/fast_jsonapi/serialization_core.rb +++ b/lib/fast_jsonapi/serialization_core.rb @@ -119,9 +119,10 @@ module FastJsonapi next unless relationships_to_serialize && relationships_to_serialize[item] relationship_item = relationships_to_serialize[item] next unless relationship_item.include_relationship?(record, params) - raise NotImplementedError if relationship_item.polymorphic.is_a?(Hash) - record_type = relationship_item.record_type - serializer = relationship_item.serializer.to_s.constantize + unless relationship_item.polymorphic.is_a?(Hash) + record_type = relationship_item.record_type + serializer = relationship_item.serializer.to_s.constantize + end relationship_type = relationship_item.relationship_type included_objects = relationship_item.fetch_associated_object(record, params) @@ -129,12 +130,17 @@ module FastJsonapi included_objects = [included_objects] unless relationship_type == :has_many included_objects.each do |inc_obj| + if relationship_item.polymorphic.is_a?(Hash) + record_type = inc_obj.class.name.demodulize.underscore + serializer = self.compute_serializer_name(inc_obj.class.name.demodulize.to_sym).to_s.constantize + end + if remaining_items(items) serializer_records = serializer.get_included_records(inc_obj, remaining_items(items), known_included_objects, fieldsets, params) included_records.concat(serializer_records) unless serializer_records.empty? end - code = "#{record_type}_#{inc_obj.id}" + code = "#{record_type}_#{serializer.id_from_record(inc_obj)}" next if known_included_objects.key?(code) known_included_objects[code] = inc_obj diff --git a/spec/lib/object_serializer_class_methods_spec.rb b/spec/lib/object_serializer_class_methods_spec.rb index 397ace5..347b188 100644 --- a/spec/lib/object_serializer_class_methods_spec.rb +++ b/spec/lib/object_serializer_class_methods_spec.rb @@ -411,4 +411,34 @@ describe FastJsonapi::ObjectSerializer do it_behaves_like 'returning key transformed hash', :movie_type, :underscore_movie_type, :release_year end end + + describe '#set_key_transform after #set_type' do + subject(:serializable_hash) { MovieSerializer.new(movie).serializable_hash } + + before do + MovieSerializer.set_type type_name + MovieSerializer.set_key_transform :camel + end + + after do + MovieSerializer.transform_method = nil + MovieSerializer.set_type :movie + end + + context 'when sets singular type name' do + let(:type_name) { :film } + + it 'returns correct hash which type equals transformed set_type value' do + expect(serializable_hash[:data][:type]).to eq :Film + end + end + + context 'when sets plural type name' do + let(:type_name) { :films } + + it 'returns correct hash which type equals transformed set_type value' do + expect(serializable_hash[:data][:type]).to eq :Films + end + end + end end diff --git a/spec/lib/object_serializer_polymorphic_spec.rb b/spec/lib/object_serializer_polymorphic_spec.rb new file mode 100644 index 0000000..f889141 --- /dev/null +++ b/spec/lib/object_serializer_polymorphic_spec.rb @@ -0,0 +1,51 @@ +require 'spec_helper' + +describe FastJsonapi::ObjectSerializer do + class List + attr_accessor :id, :name, :items + end + + class ChecklistItem + attr_accessor :id, :name + end + + class Car + attr_accessor :id, :model, :year + end + + class ListSerializer + include FastJsonapi::ObjectSerializer + set_type :list + attributes :name + set_key_transform :dash + has_many :items, polymorphic: true + end + + let(:car) do + car = Car.new + car.id = 1 + car.model = 'Toyota Corolla' + car.year = 1987 + car + end + + let(:checklist_item) do + checklist_item = ChecklistItem.new + checklist_item.id = 2 + checklist_item.name = 'Do this action!' + checklist_item + end + + context 'when serializing id and type of polymorphic relationships' do + it 'should return correct type when transform_method is specified' do + list = List.new + list.id = 1 + list.items = [checklist_item, car] + list_hash = ListSerializer.new(list).to_hash + record_type = list_hash[:data][:relationships][:items][:data][0][:type] + expect(record_type).to eq 'checklist-item'.to_sym + record_type = list_hash[:data][:relationships][:items][:data][1][:type] + expect(record_type).to eq 'car'.to_sym + end + end +end diff --git a/spec/lib/object_serializer_spec.rb b/spec/lib/object_serializer_spec.rb index 06aac37..85f4a79 100644 --- a/spec/lib/object_serializer_spec.rb +++ b/spec/lib/object_serializer_spec.rb @@ -158,6 +158,32 @@ describe FastJsonapi::ObjectSerializer do end end + context 'id attribute is the same for actors and not a primary key' do + before do + ActorSerializer.set_id :email + movie.actor_ids = [0, 0, 0] + class << movie + def actors + super.each_with_index { |actor, i| actor.email = "actor#{i}@email.com" } + end + end + end + + after { ActorSerializer.set_id nil } + + let(:options) { { include: ['actors'] } } + subject { MovieSerializer.new(movie, options).serializable_hash } + + it 'returns all actors in includes' do + + expect( + subject[:included].select { |i| i[:type] == :actor }.map { |i| i[:id] } + ).to eq( + movie.actors.map(&:email) + ) + end + end + context 'nested includes' do it 'has_many to belongs_to: returns correct nested includes when serializable_hash is called' do # 3 actors, 3 agencies @@ -252,10 +278,24 @@ describe FastJsonapi::ObjectSerializer do end end - it 'polymorphic throws an error that polymorphic is not supported' do + it 'polymorphic has_many: returns correct nested includes when serializable_hash is called' do options = {} options[:include] = [:groupees] - expect(-> { GroupSerializer.new([group], options)}).to raise_error(NotImplementedError) + + serializable_hash = GroupSerializer.new([group], options).serializable_hash + + persons_serialized = serializable_hash[:included].find_all { |included| included[:type] == :person }.map { |included| included[:id].to_i } + groups_serialized = serializable_hash[:included].find_all { |included| included[:type] == :group }.map { |included| included[:id].to_i } + + persons = group.groupees.find_all { |groupee| groupee.is_a?(Person) } + persons.each do |person| + expect(persons_serialized).to include(person.id) + end + + groups = group.groupees.find_all { |groupee| groupee.is_a?(Group) } + groups.each do |group| + expect(groups_serialized).to include(group.id) + end end end