simple_ams 0.2.1 → 0.2.6

data/lib/simple_ams/dsl.rb

@@ -1,4 +1,4 @@
-require "simple_ams"
+require 'simple_ams'
 
 module SimpleAMS::DSL
   def self.included(host_class)
@@ -17,7 +17,7 @@ module SimpleAMS::DSL
           links: links,
           metas: metas,
           forms: forms,
-          generics: generics,
+          generics: generics
         }
       end
     end
@@ -26,13 +26,13 @@ module SimpleAMS::DSL
   end
 
   module ClassMethods
-    #TODO: Shouldn't we call here super to presever user's behavior ?
+    # TODO: Shouldn't we call here super to presever user's behavior ?
     def inherited(subclass)
       subclass.with_options(
         options.merge(
-          #TODO: maybe add another group of elements under dsl?
-          #this could be DSL::Type.new(type).explicit?
-          type[-1][:_explicit] ? {} : {type: nil}
+          # TODO: maybe add another group of elements under dsl?
+          # this could be DSL::Type.new(type).explicit?
+          type[-1][:_explicit] ? {} : { type: nil }
         )
       )
 
@@ -49,16 +49,16 @@ module SimpleAMS::DSL
             links: links,
             metas: metas,
             forms: forms,
-            generics: generics,
+            generics: generics
           }
         end
       end
 
       _klass.with_options(
         self::Collection_.options.merge(
-          #TODO: maybe add another group of elements under dsl?
-          #this could be DSL::Type.new(type).explicit?
-          type[-1][:_explicit] ? {} : {type: nil}
+          # TODO: maybe add another group of elements under dsl?
+          # this could be DSL::Type.new(type).explicit?
+          type[-1][:_explicit] ? {} : { type: nil }
         )
       )
       subclass.const_set('Collection_', _klass)
@@ -72,47 +72,46 @@ module SimpleAMS::DSL
       }
     end
 
-    #TODO: Add tests !!
+    # TODO: Add tests !!
     def _default_type_name
-      if self.to_s.end_with?('::Collection_')
-        _name = self.to_s.gsub(
-          'Serializer',''
+      if to_s.end_with?('::Collection_')
+        _name = to_s.gsub(
+          'Serializer', ''
         ).gsub(
           '::Collection_', ''
         ).downcase.split('::')[-1]
 
-        return "#{_name}_collection".to_sym
+        "#{_name}_collection".to_sym
       else
-        return self.to_s.gsub('Serializer','').downcase.split('::')[-1].to_sym
+        to_s.gsub('Serializer', '').downcase.split('::')[-1].to_sym
       end
     end
+
     def with_options(options = {})
       @_options = options
       meths = SimpleAMS::DSL::ClassMethods.instance_methods(false)
       @_options.each do |key, value|
         if key == :relations
-          (value || []).each{|rel_value|
+          (value || []).each do |rel_value|
             append_relationship(rel_value)
-          }
-        elsif key.to_sym == :collection
-          #TODO: Add proc option maybe?
-          if value.is_a?(Hash)
-            collection{}.with_options(value)
           end
+        elsif key.to_sym == :collection
+          # TODO: Add proc option maybe?
+          collection {}.with_options(value) if value.is_a?(Hash)
         elsif meths.include?(key)
           if (value.is_a?(Array) && value[0].is_a?(Array)) || value.is_a?(Hash)
-            self.send(key, value)
+            send(key, value)
           else
-            self.send(key, *value)
+            send(key, *value)
           end
         else
           SimpleAMS.configuration.logger.info(
-            "SimpeAMS: #{key} is not recognized, ignoring (from #{self.to_s})"
+            "SimpeAMS: #{key} is not recognized, ignoring (from #{self})"
           )
         end
       end
 
-      return @_options
+      @_options
     end
 
     def adapter(value = nil, options = {})
@@ -129,7 +128,7 @@ module SimpleAMS::DSL
 
     def attributes(*args)
       @_attributes ||= []
-      return @_attributes.uniq if (args&.empty? || args.nil?)
+      return @_attributes.uniq if args&.empty? || args.nil?
 
       append_attributes(args)
     end
@@ -167,20 +166,20 @@ module SimpleAMS::DSL
     def embedded_class_for(name, options, block)
       embedded = Class.new(self)
       klass_name = "Embedded#{name.to_s.capitalize}Options_"
-      self.const_set(klass_name, embedded)
+      const_set(klass_name, embedded)
       embedded.with_options(
-        default_options.merge(options.select{|k| k != :serializer})
+        default_options.merge(options.reject { |k| k == :serializer })
       )
       embedded.instance_exec(&block) if block
 
-      return embedded
+      embedded
     end
 
-    #TODO: there is no memoization here, hence we ignore includes manually set !!
-    #Consider fixing it by employing an observer that will clean the instance var
-    #each time @_relations is updated
-    def includes(*args)
-      relations.map{|rel| rel[1] }
+    # TODO: there is no memoization here, hence we ignore includes manually set !!
+    # Consider fixing it by employing an observer that will clean the instance var
+    # each time @_relations is updated
+    def includes(*_args)
+      relations.map { |rel| rel[1] }
     end
 
     def link(name, value, options = {})
@@ -201,7 +200,8 @@ module SimpleAMS::DSL
 
     def links(links = [])
       return @_links ||= [] if links.empty?
-      links.map{|key, value| append_link([key, value].flatten(1))} if links.is_a?(Hash)
+
+      links.map { |key, value| append_link([key, value].flatten(1)) } if links.is_a?(Hash)
 
       @_links ||= links
     end
@@ -209,21 +209,23 @@ module SimpleAMS::DSL
     def metas(metas = [])
       return @_metas ||= [] if metas.empty?
 
-      metas.map{|key, value| append_meta([key, value].flatten(1))} if metas.is_a?(Hash)
+      metas.map { |key, value| append_meta([key, value].flatten(1)) } if metas.is_a?(Hash)
 
       @_metas ||= metas
     end
 
     def forms(forms = [])
       return @_forms ||= [] if forms.empty?
-      forms.map{|key, value| append_form([key, value].flatten(1))} if forms.is_a?(Hash)
+
+      forms.map { |key, value| append_form([key, value].flatten(1)) } if forms.is_a?(Hash)
 
       @_forms ||= forms
     end
 
     def generics(generics = [])
       return @_generics ||= [] if generics.empty?
-      generics.map{|key, value| append_generic([key, value].flatten(1))} if generics.is_a?(Hash)
+
+      generics.map { |key, value| append_generic([key, value].flatten(1)) } if generics.is_a?(Hash)
 
       @_generics ||= generics
     end
@@ -237,7 +239,7 @@ module SimpleAMS::DSL
 
       self::Collection_.type(name) if name
 
-      return self::Collection_
+      self::Collection_
     end
 
     def options
@@ -261,50 +263,50 @@ module SimpleAMS::DSL
     end
 
     private
-      def _value_hash_for(current, value, options, name)
-        _type = current || default_options[name]
-        return _type if value.nil?
 
-        return [value, options]
-      end
+    def _value_hash_for(current, value, options, name)
+      _type = current || default_options[name]
+      return _type if value.nil?
 
-      def append_relationship(rel)
-        @_relations ||= []
+      [value, options]
+    end
 
-        @_relations << rel
-      end
+    def append_relationship(rel)
+      @_relations ||= []
 
-      def append_attributes(*attrs)
-        @_attributes ||= []
+      @_relations << rel
+    end
 
-        @_attributes = (@_attributes << attrs).flatten.compact.uniq
-      end
+    def append_attributes(*attrs)
+      @_attributes ||= []
 
-      def append_link(link)
-        @_links ||= []
+      @_attributes = (@_attributes << attrs).flatten.compact.uniq
+    end
 
-        @_links << link
-      end
+    def append_link(link)
+      @_links ||= []
 
-      def append_meta(meta)
-        @_metas ||= []
+      @_links << link
+    end
 
-        @_metas << meta
-      end
+    def append_meta(meta)
+      @_metas ||= []
+
+      @_metas << meta
+    end
 
-      def append_form(form)
-        @_forms ||= []
+    def append_form(form)
+      @_forms ||= []
 
-        @_forms << form
-      end
+      @_forms << form
+    end
 
-      def append_generic(generic)
-        @_generics ||= []
+    def append_generic(generic)
+      @_generics ||= []
 
-        @_generics << generic
-      end
+      @_generics << generic
+    end
 
-      def empty_options
-      end
+    def empty_options; end
   end
 end

data/lib/simple_ams/methy.rb

@@ -2,9 +2,9 @@ module SimpleAMS::Methy
   def self.of(hash = {})
     m = Module.new
     hash.each do |key, value|
-      m.send(:define_method, key){ value }
+      m.send(:define_method, key) { value }
     end
 
-    return m
+    m
   end
 end

data/lib/simple_ams/options.rb

@@ -1,333 +1,335 @@
-require "simple_ams"
+require 'simple_ams'
 
-module SimpleAMS
-  class Options
-    include Concerns::TrackedProperties
+class SimpleAMS::Options
+  include Concerns::TrackedProperties
 
-    class Collection < self; end
+  class Collection < self; end
 
-    attr_reader :resource, :allowed_options, :injected_options
+  attr_reader :resource, :allowed_options, :injected_options
 
-    #injected_options is always a Hash object
-    def initialize(resource = nil, injected_options: {}, allowed_options: nil)
-      initialize_tracking!
-      @resource = resource
-      @injected_options = injected_options || {}
-      @_internal = @injected_options[:_internal] || {}
-      @allowed_options = allowed_options || fetch_allowed_options
-    end
-    alias collection resource
+  # injected_options is always a Hash object
+  def initialize(resource = nil, injected_options: {}, allowed_options: nil)
+    initialize_tracking!
+    @resource = resource
+    @injected_options = injected_options || {}
+    @_internal = @injected_options[:_internal] || {}
+    @allowed_options = allowed_options || fetch_allowed_options
+  end
+  alias collection resource
 
-    #performance enchancement method for non-polymorphic collections
-    def with_resource(resource)
-      @resource = resource
+  # performance enchancement method for non-polymorphic collections
+  def with_resource(resource)
+    @resource = resource
+    remove_instance_variable(:@serializer) if defined?(@serializer)
+    clean_volatile_properties!
 
-      clean_volatile_properties!
+    self
+  end
 
-      return self
-    end
+  def relation_options_for(relation_name)
+    _relation_options[relation_name] || {}
+  end
 
-    def relation_options_for(relation_name)
-      return _relation_options[relation_name] || {}
-    end
+  def primary_id
+    return tracked(:primary_id).value if tracked(:primary_id).value
 
-    def primary_id
-      return tracked(__method__).value if tracked(__method__).value
+    tracked(:primary_id).value = array_of_value_hash_for(PrimaryId, :primary_id)
+  end
 
-      return tracked(__method__).value = array_of_value_hash_for(PrimaryId, :primary_id)
-    end
+  def type
+    return tracked(:type).value if tracked(:type).value
 
-    def type
-      return tracked(__method__).value if tracked(__method__).value
+    tracked(:type).value = array_of_value_hash_for(Type, :type)
+  end
 
-      return tracked(__method__).value = array_of_value_hash_for(Type, :type)
-    end
+  def name
+    @name ||= injected_options[:name] || allowed_options[:name] || type.name
+  end
 
-    def name
-      @name ||= injected_options[:name] || allowed_options[:name] || type.name
-    end
+  # TODO: optimize for nested fields?
+  def fields
+    return @fields if defined?(@fields)
 
-    #TODO: optimize for nested fields?
-    def fields
-      return @fields if defined?(@fields)
+    @fields = array_of_items_for(Fields, :fields)
+  end
 
-      return @fields = array_of_items_for(Fields, :fields)
-    end
+  def includes
+    return @includes if defined?(@includes)
 
-    def includes
-      return @includes if defined?(@includes)
+    @includes = array_of_items_for(Includes, :includes)
+  end
 
-      return @includes = array_of_items_for(Includes, :includes)
-    end
+  # TODO: correctly loop over injected relations, although should be a rarely used feature
+  def relations
+    return @relations if defined?(@relations)
 
-    #TODO: correctly loop over injected relations, although should be a rarely used feature
-    def relations
-      return @relations if defined?(@relations)
+    relations = injected_options.fetch(:relations, nil)
+    relations = allowed_options.fetch(:relations, []) if relations.nil?
 
-      relations = injected_options.fetch(:relations, nil)
-      relations = allowed_options.fetch(:relations, []) if relations.nil?
+    @relations = Relations.new(relations, includes)
+  end
 
-      return @relations = Relations.new(relations, includes)
-    end
+  def links
+    return tracked(:links).value if tracked(:links).value
 
-    def links
-      return tracked(__method__).value if tracked(__method__).value
+    tracked(:links).value = array_of_name_value_hash_for(Links, Links::Link, :links)
+  end
 
-      return tracked(__method__).value = array_of_name_value_hash_for(Links, Links::Link, :links)
-    end
+  def metas
+    return tracked(:metas).value if tracked(:metas).value
 
-    def metas
-      return tracked(__method__).value if tracked(__method__).value
+    tracked(:metas).value = array_of_name_value_hash_for(Metas, Metas::Meta, :metas)
+  end
 
-      return tracked(__method__).value = array_of_name_value_hash_for(Metas, Metas::Meta, :metas)
-    end
+  def forms
+    return tracked(:forms).value if tracked(:forms).value
 
-    def forms
-      return tracked(__method__).value if tracked(__method__).value
+    tracked(:forms).value = array_of_name_value_hash_for(Forms, Forms::Form, :forms)
+  end
 
-      return tracked(__method__).value = array_of_name_value_hash_for(Forms, Forms::Form, :forms)
-    end
+  def generics
+    return tracked(:generics).value if tracked(:generics).value
 
-    def generics
-      return tracked(__method__).value if tracked(__method__).value
+    tracked(:generics).value = array_of_name_value_hash_for(
+      Generics, Generics::Option, :generics
+    )
+  end
 
-      return tracked(__method__).value = array_of_name_value_hash_for(
-        Generics, Generics::Option, :generics
-      )
-    end
+  # TODO: handle case of proc
+  def serializer
+    return @serializer if defined?(@serializer)
 
-    #TODO: handle case of proc
-    def serializer
-      return @serializer if defined?(@serializer)
+    _serializer = injected_options.fetch(:serializer, serializer_class)
 
-      _serializer = injected_options.fetch(:serializer, serializer_class)
+    @serializer = instantiated_serializer_for(_serializer)
+  end
 
-      return @serializer = instantiated_serializer_for(_serializer)
-    end
+  def adapter(_serializer: nil)
+    return @adapter if defined?(@adapter) && _serializer.nil?
 
-    def adapter(_serializer: nil)
-      return @adapter if defined?(@adapter) && _serializer.nil?
-      serializer = _serializer || serializer
+    serializer = _serializer || serializer
 
-      @adapter = Adapter.new(*injected_options.fetch(:adapter, [nil]), {
+    @adapter = Adapter.new(
+      *injected_options.fetch(:adapter, [nil]),
+      resource: resource, serializer: serializer
+    )
+    if @adapter.value.nil?
+      @adapter = Adapter.new(
+        *allowed_options.fetch(:adapter, [nil]),
         resource: resource, serializer: serializer
-      })
-      if @adapter.value.nil?
-        @adapter = Adapter.new(*allowed_options.fetch(:adapter, [nil]), {
-          resource: resource, serializer: serializer
-        })
-      end
-=begin
-      if @adapter.value.nil?
-        @adapter = Adapter.new(SimpleAMS::Adapters::AMS, {
-          resource: resource, serializer: serializer
-        })
-      end
-=end
-
-      return @adapter
+      )
     end
+    #       if @adapter.value.nil?
+    #         @adapter = Adapter.new(SimpleAMS::Adapters::AMS, {
+    #           resource: resource, serializer: serializer
+    #         })
+    #       end
 
-    # the following should be the same for all (nested) serializers of the same document
-    def expose
-      @expose ||= injected_options.fetch(:expose, {})
-    end
+    @adapter
+  end
 
-    def as_hash
-      {
-        adapter: adapter.raw,
-        primary_id: primary_id.raw,
-        type: type.raw,
-        name: name,
-        fields: fields.raw,
-        serializer: serializer_class,
-        #relations: relations.raw, #TODO: why have I commented that out ?
-        includes: includes.raw,
-        links: links.raw,
-        metas: metas.raw,
-        expose: expose,
-        _internal: _internal
-      }
-    end
+  # the following should be the same for all (nested) serializers of the same document
+  def expose
+    @expose ||= injected_options.fetch(:expose, {})
+  end
 
-    def collection_options
-      return @collection_options if defined?(@collection_options)
-
-      #TODO: Do we need that merge ?
-      _injected_options = @injected_options.fetch(:collection, {}).merge({
-        serializer: collection_serializer_class,
-        adapter: adapter(_serializer: collection_serializer_class).raw,
-        expose: expose
-      })
-      _allowed_options = @allowed_options.fetch(:collection).options
-
-      return @collection_options = self.class::Collection.new(
-        resource,
-        injected_options: _injected_options,
-        allowed_options: _allowed_options
-      )
-    end
+  def as_hash
+    {
+      adapter: adapter.raw,
+      primary_id: primary_id.raw,
+      type: type.raw,
+      name: name,
+      fields: fields.raw,
+      serializer: serializer_class,
+      # relations: relations.raw, #TODO: why have I commented that out ?
+      includes: includes.raw,
+      links: links.raw,
+      metas: metas.raw,
+      expose: expose,
+      _internal: _internal
+    }
+  end
 
-    def serializer_class
-      return @serializer_class if defined?(@serializer_class)
+  def collection_options
+    return @collection_options if defined?(@collection_options)
+
+    # TODO: Do we need that merge ?
+    _injected_options = @injected_options.fetch(:collection, {}).merge({
+      serializer: collection_serializer_class,
+      adapter: adapter(_serializer: collection_serializer_class).raw,
+      expose: expose
+    })
+    _allowed_options = @allowed_options.fetch(:collection).options
+
+    @collection_options = self.class::Collection.new(
+      resource,
+      injected_options: _injected_options,
+      allowed_options: _allowed_options
+    )
+  end
 
-      @serializer_class = injected_options.fetch(:serializer, nil)
+  def serializer_class
+    return @serializer_class if defined?(@serializer_class)
 
-      return @serializer_class if @serializer_class 
+    @serializer_class = injected_options.fetch(:serializer, nil)
 
-      return @serializer_class = infer_serializer
-    end
+    return @serializer_class if @serializer_class
+
+    @serializer_class = infer_serializer
+  end
 
-    #TODO: maybe have that inside :collection? (isomorphism)
-    def collection_serializer_class
-      return @collection_serializer_class if defined?(@collection_serializer_class)
+  # TODO: maybe have that inside :collection? (isomorphism)
+  def collection_serializer_class
+    return @collection_serializer_class if defined?(@collection_serializer_class)
 
-      if serializer_class.is_a?(Proc) #TODO: maybe we should do duck typing instead?
-        @collection_serializer_class = injected_options[:collection_serializer]
-        if @collection_serializer_class.nil?
-          raise "In case of a proc serializer, you need to specify a collection_serializer"
-        end
-      else
-        @collection_serializer_class = serializer_class
+    if serializer_class.is_a?(Proc) # TODO: maybe we should do duck typing instead?
+      @collection_serializer_class = injected_options[:collection_serializer]
+      if @collection_serializer_class.nil?
+        raise 'In case of a proc serializer, you need to specify a collection_serializer'
       end
-
-      return @collection_serializer_class
+    else
+      @collection_serializer_class = serializer_class
     end
 
-    private
-      attr_reader :_internal
-
-      #TODO: add method-based links, should boost performance
-      def array_of_name_value_hash_for(collection_klass, item_klass, name)
-        injected = injected_options.fetch(name, nil)
-        if injected
-          injected = collection_klass.new(
-            injected.map{|l| item_klass.new(*l.flatten, {
-              resource: resource, serializer: serializer
-            })}
+    @collection_serializer_class
+  end
+
+  private
+
+  attr_reader :_internal
+
+  # TODO: add method-based links, should boost performance
+  def array_of_name_value_hash_for(collection_klass, item_klass, name)
+    injected = injected_options.fetch(name, nil)
+    if injected
+      injected = collection_klass.new(
+        injected.map do |l|
+          item_klass.new(
+            *l.flatten,
+            resource: resource, serializer: serializer
           )
         end
+      )
+    end
 
-        allowed = collection_klass.new(
-          allowed_options.fetch(name).map{|l| item_klass.new(*l, {
-            resource: resource, serializer: serializer
-          })}
+    allowed = collection_klass.new(
+      allowed_options.fetch(name).map do |l|
+        item_klass.new(
+          *l,
+          resource: resource, serializer: serializer
         )
-
-        return collection_klass.new(priority_options_for(
-          #TODO: correctly loop over injected properties
-          injected: injected,
-          allowed: allowed,
-        ).uniq{|item| item.name})
       end
+    )
 
-      def array_of_value_hash_for(klass, name)
-        _options = injected_options.fetch(name, nil)
-        _options = allowed_options.fetch(name, nil) unless _options
+    collection_klass.new(priority_options_for(
+      # TODO: correctly loop over injected properties
+      injected: injected,
+      allowed: allowed
+    ).uniq(&:name))
+  end
 
-        return klass.new(*_options, {
-          resource: resource, serializer: serializer
-        })
-      end
+  def array_of_value_hash_for(klass, name)
+    _options = injected_options.fetch(name, nil)
+    _options ||= allowed_options.fetch(name, nil)
 
-      def array_of_items_for(klass, name)
-        injected = injected_options.fetch(name, nil)
+    klass.new(
+      *_options,
+      resource: resource, serializer: serializer
+    )
+  end
 
-        if injected.nil?
-          return klass.new(allowed_options.fetch(name).uniq)
-        else
-          return klass.new(priority_options_for(
-            injected: klass.new(injected_options.fetch(name, nil)),
-            allowed: klass.new(allowed_options.fetch(name).uniq)
-          ).uniq)
-        end
-      end
+  def array_of_items_for(klass, name)
+    injected = injected_options.fetch(name, nil)
 
-      def priority_options_for(allowed:, injected:)
-        if not injected.nil?
-          allowed = injected.class.new(
-            injected.map{|s| s.is_a?(Hash) ? (s.first && s.first[0]) : s}
-          ) & allowed
-        end
+    if injected.nil?
+      klass.new(allowed_options.fetch(name).uniq)
+    else
+      klass.new(priority_options_for(
+        injected: klass.new(injected_options.fetch(name, nil)),
+        allowed: klass.new(allowed_options.fetch(name).uniq)
+      ).uniq)
+    end
+  end
 
-        return allowed
-      end
+  def priority_options_for(allowed:, injected:)
+    unless injected.nil?
+      allowed = injected.class.new(
+        injected.map { |s| s.is_a?(Hash) ? s.keys : s }.flatten
+      ) & allowed
+    end
 
-=begin
-      def options_for(allowed:, injected:)
-        (allowed || []).concat(injected || [])
-      end
-=end
-
-      def _relation_options
-        return @_relation_options if defined?(@_relation_options)
-
-        @_relation_options = relations.inject({}){|memo, relation|
-          includes_value = (injected_options[:includes] || {}).find{|incl_hash|
-            incl_hash.is_a?(Hash) &&
-              (incl_hash.first && incl_hash.first[0]).to_s == relation.name.to_s
-          }
-          if includes_value
-            includes_value = includes_value[relation.name]
-          else
-            #it's important here to return empty array if nothing is found..
-            includes_value = []
-          end
-
-          fields_value = (injected_options[:fields] || {}).find{|field_hash|
-            field_hash.is_a?(Hash) &&
-              (field_hash.first && field_hash.first[0]).to_s == relation.name.to_s
-          }
-
-          #.. while here just nil will work (pick default fields from serializer)
-          fields_value = fields_value[relation.name] if fields_value
-
-          memo[relation.name] = {
-            includes: includes_value,
-            fields: fields_value
-          }
-          memo
-        }
-      end
+    allowed
+  end
 
-      #TODO: raise exception if both are nil!
-      def fetch_allowed_options
-        _serializer_class = self.serializer_class
-        if _serializer_class.is_a?(Proc) #TODO: maybe we should do duck typing instead?
-          _serializer_class = self.collection_serializer_class
-        end
+  def _relation_options
+    return @_relation_options if defined?(@_relation_options)
 
-        if _serializer_class.respond_to?(:simple_ams?)
-          return _serializer_class&.options
-        else
-          raise "#{_serializer_class} does not respond to SimpleAMS methods, did you include the DSL module?"
-        end
-      end
+    # TODO: should use 2.7 filter_map soon
+    @_relation_options = relations.each_with_object({}) do |relation, memo|
+      includes_value = (injected_options[:includes] || {}).find do |incl_hash|
+        next unless incl_hash.is_a?(Hash)
 
-      def instantiated_serializer_for(serializer_klass)
-        serializer_klass.new.extend(
-          SimpleAMS::Methy.of(
-            expose.merge({
-              object: resource
-            })
-          )
-        )
+        incl_hash.keys.include?(relation.name)
       end
+      includes_value = if includes_value
+                         includes_value[relation.name]
+                       else
+                         # it's important here to return empty array if nothing is found..
+                         []
+                       end
 
-      def infer_serializer
-        namespace = _internal[:module] ? "#{_internal[:module]}::" : ""
-        resource_klass = resource.kind_of?(Array) ? resource[0].class : resource.class
-        if resource_klass == NilClass
-          return EmptySerializer
-        else
-          return Object.const_get("#{namespace}#{resource_klass.to_s}Serializer")
-        end
-      rescue NameError => _
-        raise "Could not infer serializer for #{resource.class}, maybe specify it? (tried #{namespace}#{resource_klass.to_s}Serializer)"
-      end
+      fields_value = (injected_options[:fields] || {}).find do |field_hash|
+        next unless field_hash.is_a?(Hash)
 
-      class EmptySerializer
-        include SimpleAMS::DSL
+        field_hash.keys.include?(relation.name)
       end
+
+      # .. while here just nil will work (pick default fields from serializer)
+      fields_value = fields_value[relation.name] if fields_value
+
+      memo[relation.name] = {
+        includes: includes_value,
+        fields: fields_value
+      }
+    end
+  end
+
+  # TODO: raise exception if both are nil!
+  def fetch_allowed_options
+    _serializer_class = serializer_class
+    _serializer_class = collection_serializer_class if _serializer_class.is_a?(Proc)
+
+    unless _serializer_class.respond_to?(:simple_ams?)
+      raise "#{_serializer_class} does not respond to SimpleAMS methods, did you include the DSL module?"
+    end
+
+    _serializer_class&.options
+  end
+
+  def instantiated_serializer_for(serializer_klass)
+    serializer_klass.new.extend(
+      SimpleAMS::Methy.of(
+        expose.merge({
+          object: resource
+        })
+      )
+    )
+  end
+
+  def infer_serializer
+    namespace = _internal[:module] ? "#{_internal[:module]}::" : ''
+    resource_klass = resource.respond_to?(:to_a) && resource.respond_to?(:last) ? resource[0].class : resource.class
+    if resource_klass == NilClass
+      EmptySerializer
+    else
+      Object.const_get("#{namespace}#{resource_klass}Serializer")
+    end
+  rescue NameError => _e
+    tried = "#{namespace}#{resource_klass}Serializer"
+    raise "Could not infer serializer for #{resource.class}, maybe specify it? (tried #{tried})"
+  end
+
+  class EmptySerializer
+    include SimpleAMS::DSL
   end
 end