Allow customization of the inclusion level in the serializer

Author: benedikt

lib/userlist/push/serializer.rb

@@ -9,8 +9,9 @@ def self.serialize(resource, **options)
 
       attr_reader :context
 
-      def initialize(context:)
+      def initialize(context:, include: nil)
         @context = context
+        @include = normalize_include_options(include)
       end
 
       def serialize(resource)
@@ -28,7 +29,7 @@ def serialize?(resource)
     private
 
       def serialize_resource(resource)
-        return resource.identifier if serialized_resources.include?(resource)
+        return serialize_identifier(resource) if serialized?(resource)
 
         serialized_resources << resource
 
@@ -37,34 +38,48 @@ def serialize_resource(resource)
         serialized = {}
 
         resource.attribute_names.each do |name|
-          serialized[name] = resource.send(name)
+          serialized[name] = serialize_attribute(resource, name)
         end
 
         resource.association_names.each do |name|
-          next unless result = serialize_association(resource.send(name))
+          next unless result = serialize_association(resource, name)
 
           serialized[name] = result
         end
 
         serialized
       end
 
-      def serialize_association(association)
-        return unless association
+      def serialize_attribute(resource, name)
+        resource.send(name)
+      end
+
+      def serialize_association(resource, name)
+        return unless association = resource.send(name)
+        return serialize_identifier(association) unless include?(name)
+
+        with_include_for(name) do
+          case association
+          when Userlist::Push::ResourceCollection
+            serialize_collection(association)
+          when Userlist::Push::Resource
+            serialize_resource(association)
+          else
+            raise "Cannot serialize association type: #{association.class}"
+          end
+        end
+      end
 
-        case association
-        when Userlist::Push::ResourceCollection
-          serialize_collection(association)
+      def serialize_identifier(resource)
+        case resource
         when Userlist::Push::Resource
-          serialize_resource(association)
-        else
-          raise "Cannot serialize association type: #{association.class}"
+          resource.identifier
         end
       end
 
       def serialize_collection(collection)
         serialized = collection
-          .map(&method(:serialize_association))
+          .map(&method(:serialize_resource))
           .compact
           .reject(&:empty?)
 
@@ -74,6 +89,36 @@ def serialize_collection(collection)
       def serialized_resources
         @serialized_resources ||= Set.new
       end
+
+      def serialized?(resource)
+        serialized_resources.include?(resource)
+      end
+
+      def include?(name)
+        @include.nil? || @include.fetch(name.to_sym, false)
+      end
+
+      def with_include_for(name)
+        original_include = @include
+        @include = @include&.fetch(name.to_sym, false)
+
+        yield
+      ensure
+        @include = original_include
+      end
+
+      def normalize_include_options(value)
+        case value
+        when Array
+          value.inject({}) { |acc, v| acc.merge(normalize_include_options(v)) }
+        when Hash
+          value.to_h { |k, v| [k.to_sym, normalize_include_options(v)] }
+        when Symbol, String
+          { value.to_sym => {} }
+        when false
+          {}
+        end
+      end
     end
   end
 end

spec/userlist/push/serializer_spec.rb

@@ -192,6 +192,119 @@
           )
         end
       end
+
+      describe 'include option' do
+        let(:other_user) do
+          Userlist::Push::User.new(
+            identifier: 'other-user-identifier',
+            email: '[email protected]'
+          )
+        end
+
+        let(:other_relationship) do
+          Userlist::Push::Relationship.new(
+            user: other_user,
+            company: company,
+            properties: {
+              role: 'member'
+            }
+          )
+        end
+
+        before do
+          company.relationships = [relationship, other_relationship]
+        end
+
+        context 'when the include option is set to false' do
+          subject { described_class.new(context: :push, include: false) }
+
+          it 'should not include relationships' do
+            expect(payload).to eq(
+              identifier: 'user-identifier',
+              email: '[email protected]',
+              signed_up_at: nil
+            )
+          end
+        end
+
+        context 'when the include option is set to :relationships' do
+          subject { described_class.new(context: :push, include: :relationships) }
+
+          it 'should include relationships' do
+            expect(payload).to eq(
+              identifier: 'user-identifier',
+              email: '[email protected]',
+              signed_up_at: nil,
+              relationships: [
+                {
+                  user: 'user-identifier',
+                  company: 'company-identifier',
+                  properties: {
+                    role: 'admin'
+                  }
+                }
+              ]
+            )
+          end
+        end
+
+        context 'when the include option is set to { relationships: [:company] }' do
+          subject { described_class.new(context: :push, include: [{ relationships: [{ company: [] }] }]) }
+
+          it 'should include relationships' do
+            expect(payload).to eq(
+              identifier: 'user-identifier',
+              email: '[email protected]',
+              signed_up_at: nil,
+              relationships: [
+                {
+                  user: 'user-identifier',
+                  company: {
+                    identifier: 'company-identifier',
+                    name: 'Example, Inc.',
+                    signed_up_at: nil
+                  },
+                  properties: {
+                    role: 'admin'
+                  }
+                }
+              ]
+            )
+          end
+        end
+
+        context 'when the include option is set to { relationships: { company: :relationships } }' do
+          subject { described_class.new(context: :push, include: { relationships: { company: :relationships } }) }
+
+          it 'should include relationships' do
+            expect(payload).to eq(
+              identifier: 'user-identifier',
+              email: '[email protected]',
+              signed_up_at: nil,
+              relationships: [
+                {
+                  user: 'user-identifier',
+                  company: {
+                    identifier: 'company-identifier',
+                    name: 'Example, Inc.',
+                    signed_up_at: nil,
+                    relationships: [
+                      {
+                        company: 'company-identifier',
+                        user: 'other-user-identifier',
+                        properties: { role: 'member' }
+                      }
+                    ]
+                  },
+                  properties: {
+                    role: 'admin'
+                  }
+                }
+              ]
+            )
+          end
+        end
+      end
     end
 
     context 'when serializing the company' do