dulead-jsonapi-serializer 2.2.0

data/lib/extensions/has_one.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+::ActiveRecord::Associations::Builder::HasOne.class_eval do
+  # Based on
+  # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/associations/builder/collection_association.rb#L50
+  # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/associations/builder/singular_association.rb#L11
+  def self.define_accessors(mixin, reflection)
+    super
+    name = reflection.name
+    mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+      def #{name}_id
+        # if an attribute is already defined with this methods name we should just use it
+        return read_attribute(__method__) if has_attribute?(__method__)
+        association(:#{name}).reader.try(:id)
+      end
+    CODE
+  end
+end

data/lib/fast_jsonapi/attribute.rb

@@ -0,0 +1,5 @@
+require 'fast_jsonapi/scalar'
+
+module FastJsonapi
+  class Attribute < Scalar; end
+end

data/lib/fast_jsonapi/helpers.rb

@@ -0,0 +1,21 @@
+module FastJsonapi
+  class << self
+    # Calls either a Proc or a Lambda, making sure to never pass more parameters to it than it can receive
+    #
+    # @param [Proc] proc the Proc or Lambda to call
+    # @param [Array<Object>] *params any number of parameters to be passed to the Proc
+    # @return [Object] the result of the Proc call with the supplied parameters
+    def call_proc(proc, *params)
+      # The parameters array for a lambda created from a symbol (&:foo) differs
+      # from explictly defined procs/lambdas, so we can't deduce the number of
+      # parameters from the array length (and differs between Ruby 2.x and 3).
+      # In the case of negative arity -- unlimited/unknown argument count --
+      # just send the object to act as the method receiver.
+      if proc.arity.negative?
+        proc.call(params.first)
+      else
+        proc.call(*params.take(proc.parameters.length))
+      end
+    end
+  end
+end

data/lib/fast_jsonapi/instrumentation/skylight.rb

@@ -0,0 +1,3 @@
+require 'skylight'
+
+warn('DEPRECATION: Skylight support was moved into the `skylight` gem.')

data/lib/fast_jsonapi/instrumentation.rb

@@ -0,0 +1,7 @@
+require 'jsonapi/serializer/instrumentation'
+
+warn(
+  'DEPRECATION: Performance instrumentation is no longer automatic. See: ' \
+  'https://github.com/jsonapi-serializer/jsonapi-serializer' \
+  '#performance-instrumentation'
+)

data/lib/fast_jsonapi/link.rb

@@ -0,0 +1,5 @@
+require 'fast_jsonapi/scalar'
+
+module FastJsonapi
+  class Link < Scalar; end
+end

data/lib/fast_jsonapi/object_serializer.rb

@@ -0,0 +1,357 @@
+# frozen_string_literal: true
+
+require 'active_support/time'
+require 'active_support/concern'
+require 'active_support/inflector'
+require 'active_support/core_ext/numeric/time'
+require 'fast_jsonapi/helpers'
+require 'fast_jsonapi/attribute'
+require 'fast_jsonapi/relationship'
+require 'fast_jsonapi/link'
+require 'fast_jsonapi/serialization_core'
+
+module FastJsonapi
+  module ObjectSerializer
+    extend ActiveSupport::Concern
+    include SerializationCore
+
+    TRANSFORMS_MAPPING = {
+      camel: :camelize,
+      camel_lower: [:camelize, :lower],
+      dash: :dasherize,
+      underscore: :underscore
+    }.freeze
+
+    included do
+      # Set record_type based on the name of the serializer class
+      set_type(reflected_record_type) if reflected_record_type
+    end
+
+    def initialize(resource, options = {})
+      process_options(options)
+
+      @resource = resource
+    end
+
+    def serializable_hash
+      if self.class.is_collection?(@resource, @is_collection)
+        return hash_for_collection
+      end
+
+      hash_for_one_record
+    end
+    alias to_hash serializable_hash
+
+    def hash_for_one_record
+      serializable_hash = { data: nil }
+      serializable_hash[:meta] = @meta if @meta.present?
+      serializable_hash[:links] = @links if @links.present?
+
+      return serializable_hash unless @resource
+
+      serializable_hash[:data] = self.class.record_hash(@resource, @fieldsets[self.class.record_type.to_sym], @includes, @params)
+      serializable_hash[:included] = self.class.get_included_records(@resource, @includes, @known_included_objects, @fieldsets, @params) if @includes.present?
+      serializable_hash
+    end
+
+    def hash_for_collection
+      serializable_hash = {}
+
+      data = []
+      included = []
+      fieldset = @fieldsets[self.class.record_type.to_sym]
+      @resource.each do |record|
+        data << self.class.record_hash(record, fieldset, @includes, @params)
+        included.concat self.class.get_included_records(record, @includes, @known_included_objects, @fieldsets, @params) if @includes.present?
+      end
+
+      serializable_hash[:data] = data
+      serializable_hash[:included] = included if @includes.present?
+      serializable_hash[:meta] = @meta if @meta.present?
+      serializable_hash[:links] = @links if @links.present?
+      serializable_hash
+    end
+
+    private
+
+    def process_options(options)
+      @fieldsets = deep_symbolize(options[:fields].presence || {})
+      @params = {}
+
+      return if options.blank?
+
+      @known_included_objects = Set.new
+      @meta = options[:meta]
+      @links = options[:links]
+      @is_collection = options[:is_collection]
+      @params = options[:params] || {}
+      raise ArgumentError, '`params` option passed to serializer must be a hash' unless @params.is_a?(Hash)
+
+      if options[:include].present?
+        @includes = options[:include].reject(&:blank?).map(&:to_sym)
+        self.class.validate_includes!(@includes)
+      end
+    end
+
+    def deep_symbolize(collection)
+      if collection.is_a? Hash
+        collection.each_with_object({}) do |(k, v), hsh|
+          hsh[k.to_sym] = deep_symbolize(v)
+        end
+      elsif collection.is_a? Array
+        collection.map { |i| deep_symbolize(i) }
+      else
+        collection.to_sym
+      end
+    end
+
+    class_methods do
+      # Detects a collection/enumerable
+      #
+      # @return [TrueClass] on a successful detection
+      def is_collection?(resource, force_is_collection = nil)
+        return force_is_collection unless force_is_collection.nil?
+
+        resource.is_a?(Enumerable) && !resource.respond_to?(:each_pair)
+      end
+
+      def inherited(subclass)
+        super(subclass)
+        subclass.attributes_to_serialize = attributes_to_serialize.dup if attributes_to_serialize.present?
+        subclass.relationships_to_serialize = relationships_to_serialize.dup if relationships_to_serialize.present?
+        subclass.cachable_relationships_to_serialize = cachable_relationships_to_serialize.dup if cachable_relationships_to_serialize.present?
+        subclass.uncachable_relationships_to_serialize = uncachable_relationships_to_serialize.dup if uncachable_relationships_to_serialize.present?
+        subclass.transform_method = transform_method
+        subclass.data_links = data_links.dup if data_links.present?
+        subclass.cache_store_instance = cache_store_instance
+        subclass.cache_store_options = cache_store_options
+        subclass.set_type(subclass.reflected_record_type) if subclass.reflected_record_type
+        subclass.meta_to_serialize = meta_to_serialize
+        subclass.record_id = record_id
+        subclass.record_type_block = record_type_block
+      end
+
+      def reflected_record_type
+        return @reflected_record_type if defined?(@reflected_record_type)
+
+        @reflected_record_type ||= begin
+          name.split('::').last.chomp('Serializer').underscore.to_sym if name&.end_with?('Serializer')
+        end
+      end
+
+      def set_key_transform(transform_name)
+        self.transform_method = TRANSFORMS_MAPPING[transform_name.to_sym]
+
+        # ensure that the record type is correctly transformed
+        if record_type
+          set_type(record_type)
+        # TODO: Remove dead code
+        elsif reflected_record_type
+          set_type(reflected_record_type)
+        end
+      end
+
+      def run_key_transform(input)
+        if transform_method.present?
+          input.to_s.send(*@transform_method).to_sym
+        else
+          input.to_sym
+        end
+      end
+
+      def use_hyphen
+        warn('DEPRECATION WARNING: use_hyphen is deprecated and will be removed from fast_jsonapi 2.0 use (set_key_transform :dash) instead')
+        set_key_transform :dash
+      end
+
+      def set_type(type_name)
+        self.record_type = run_key_transform(type_name)
+      end
+
+      def set_id(id_name = nil, &block)
+        self.record_id = block || id_name
+      end
+
+      def set_record_type_block(&block)
+        self.record_type_block = block
+      end
+
+      def cache_options(cache_options)
+        # FIXME: remove this if block once deprecated cache_options are not supported anymore
+        unless cache_options.key?(:store)
+          # fall back to old, deprecated behaviour because no store was passed.
+          # we assume the user explicitly wants new behaviour if he passed a
+          # store because this is the new syntax.
+          deprecated_cache_options(cache_options)
+          return
+        end
+
+        self.cache_store_instance = cache_options[:store]
+        self.cache_store_options = cache_options.except(:store)
+      end
+
+      # FIXME: remove this method once deprecated cache_options are not supported anymore
+      def deprecated_cache_options(cache_options)
+        warn('DEPRECATION WARNING: `store:` is a required cache option, we will default to `Rails.cache` for now. See https://github.com/fast-jsonapi/fast_jsonapi#caching for more information.')
+
+        %i[enabled cache_length].select { |key| cache_options.key?(key) }.each do |key|
+          warn("DEPRECATION WARNING: `#{key}` is a deprecated cache option and will have no effect soon. See https://github.com/fast-jsonapi/fast_jsonapi#caching for more information.")
+        end
+
+        self.cache_store_instance = cache_options[:enabled] ? Rails.cache : nil
+        self.cache_store_options = {
+          expires_in: cache_options[:cache_length] || 5.minutes,
+          race_condition_ttl: cache_options[:race_condition_ttl] || 5.seconds
+        }
+      end
+
+      def attributes(*attributes_list, &block)
+        attributes_list = attributes_list.first if attributes_list.first.class.is_a?(Array)
+        options = attributes_list.last.is_a?(Hash) ? attributes_list.pop : {}
+        self.attributes_to_serialize = {} if attributes_to_serialize.nil?
+
+        # to support calling `attribute` with a lambda, e.g `attribute :key, ->(object) { ... }`
+        block = attributes_list.pop if attributes_list.last.is_a?(Proc)
+
+        attributes_list.each do |attr_name|
+          method_name = attr_name
+          key = run_key_transform(method_name)
+          attributes_to_serialize[key] = Attribute.new(
+            key: key,
+            method: block || method_name,
+            options: options
+          )
+        end
+      end
+
+      alias_method :attribute, :attributes
+
+      def add_relationship(relationship)
+        self.relationships_to_serialize = {} if relationships_to_serialize.nil?
+        self.cachable_relationships_to_serialize = {} if cachable_relationships_to_serialize.nil?
+        self.uncachable_relationships_to_serialize = {} if uncachable_relationships_to_serialize.nil?
+
+        # TODO: Remove this undocumented option.
+        #   Delegate the caching to the serializer exclusively.
+        if relationship.cached
+          cachable_relationships_to_serialize[relationship.name] = relationship
+        else
+          uncachable_relationships_to_serialize[relationship.name] = relationship
+        end
+        relationships_to_serialize[relationship.name] = relationship
+      end
+
+      def has_many(relationship_name, options = {}, &block)
+        relationship = create_relationship(relationship_name, :has_many, options, block)
+        add_relationship(relationship)
+      end
+
+      def has_one(relationship_name, options = {}, &block)
+        relationship = create_relationship(relationship_name, :has_one, options, block)
+        add_relationship(relationship)
+      end
+
+      def belongs_to(relationship_name, options = {}, &block)
+        relationship = create_relationship(relationship_name, :belongs_to, options, block)
+        add_relationship(relationship)
+      end
+
+      def meta(meta_name = nil, &block)
+        self.meta_to_serialize = block || meta_name
+      end
+
+      def create_relationship(base_key, relationship_type, options, block)
+        name = base_key.to_sym
+        if relationship_type == :has_many
+          base_serialization_key = base_key.to_s.singularize
+          id_postfix = '_ids'
+        else
+          base_serialization_key = base_key
+          id_postfix = '_id'
+        end
+        polymorphic = fetch_polymorphic_option(options)
+
+        Relationship.new(
+          owner: self,
+          key: options[:key] || run_key_transform(base_key),
+          name: name,
+          id_method_name: compute_id_method_name(
+            options[:id_method_name],
+            "#{base_serialization_key}#{id_postfix}".to_sym,
+            polymorphic,
+            options[:serializer],
+            block
+          ),
+          record_type: options[:record_type],
+          object_method_name: options[:object_method_name] || name,
+          object_block: block,
+          serializer: options[:serializer],
+          relationship_type: relationship_type,
+          cached: options[:cached],
+          polymorphic: polymorphic,
+          conditional_proc: options[:if],
+          transform_method: @transform_method,
+          meta: options[:meta],
+          links: options[:links],
+          lazy_load_data: options[:lazy_load_data]
+        )
+      end
+
+      def compute_id_method_name(custom_id_method_name, id_method_name_from_relationship, polymorphic, serializer, block)
+        if block.present? || serializer.is_a?(Proc) || polymorphic
+          custom_id_method_name || :id
+        else
+          custom_id_method_name || id_method_name_from_relationship
+        end
+      end
+
+      def serializer_for(name)
+        namespace = self.name.gsub(/()?\w+Serializer$/, '')
+        serializer_name = "#{name.to_s.demodulize.classify}Serializer"
+        serializer_class_name = namespace + serializer_name
+        begin
+          serializer_class_name.constantize
+        rescue NameError
+          raise NameError, "#{self.name} cannot resolve a serializer class for '#{name}'.  " \
+                           "Attempted to find '#{serializer_class_name}'. " \
+                           'Consider specifying the serializer directly through options[:serializer].'
+        end
+      end
+
+      def fetch_polymorphic_option(options)
+        option = options[:polymorphic]
+        return false unless option.present?
+        return option if option.respond_to? :keys
+
+        {}
+      end
+
+      # def link(link_name, link_method_name = nil, &block)
+      def link(*params, &block)
+        self.data_links = {} if data_links.nil?
+
+        options = params.last.is_a?(Hash) ? params.pop : {}
+        link_name = params.first
+        link_method_name = params[-1]
+        key = run_key_transform(link_name)
+
+        data_links[key] = Link.new(
+          key: key,
+          method: block || link_method_name,
+          options: options
+        )
+      end
+
+      def validate_includes!(includes)
+        return if includes.blank?
+
+        parse_includes_list(includes).each_key do |include_item|
+          relationship_to_include = relationships_to_serialize[include_item]
+          raise(JSONAPI::Serializer::UnsupportedIncludeError.new(include_item, name)) unless relationship_to_include
+
+          relationship_to_include.static_serializer # called for a side-effect to check for a known serializer class.
+        end
+      end
+    end
+  end
+end

data/lib/fast_jsonapi/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+
+class Railtie < Rails::Railtie
+  initializer 'fast_jsonapi.active_record' do
+    ActiveSupport.on_load :active_record do
+      require 'extensions/has_one'
+    end
+  end
+end

data/lib/fast_jsonapi/relationship.rb

@@ -0,0 +1,236 @@
+module FastJsonapi
+  class Relationship
+    attr_reader :owner, :key, :name, :id_method_name, :record_type, :object_method_name, :object_block, :serializer, :relationship_type, :cached, :polymorphic, :conditional_proc, :transform_method, :links, :meta, :lazy_load_data
+
+    def initialize(
+      owner:,
+      key:,
+      name:,
+      id_method_name:,
+      record_type:,
+      object_method_name:,
+      object_block:,
+      serializer:,
+      relationship_type:,
+      polymorphic:,
+      conditional_proc:,
+      transform_method:,
+      links:,
+      meta:,
+      cached: false,
+      lazy_load_data: false
+    )
+      @owner = owner
+      @key = key
+      @name = name
+      @id_method_name = id_method_name
+      @record_type = record_type
+      @object_method_name = object_method_name
+      @object_block = object_block
+      @serializer = serializer
+      @relationship_type = relationship_type
+      @cached = cached
+      @polymorphic = polymorphic
+      @conditional_proc = conditional_proc
+      @transform_method = transform_method
+      @links = links || {}
+      @meta = meta || {}
+      @lazy_load_data = lazy_load_data
+      @record_types_for = {}
+      @serializers_for_name = {}
+    end
+
+    def serialize(record, included, serialization_params, output_hash)
+      if include_relationship?(record, serialization_params)
+        empty_case = relationship_type == :has_many ? [] : nil
+
+        output_hash[key] = {}
+        output_hash[key][:data] = ids_hash_from_record_and_relationship(record, serialization_params) || empty_case unless lazy_load_data && !included
+
+        add_meta_hash(record, serialization_params, output_hash) if meta.present?
+        add_links_hash(record, serialization_params, output_hash) if links.present?
+      end
+    end
+
+    def fetch_associated_object(record, params)
+      return FastJsonapi.call_proc(object_block, record, params) unless object_block.nil?
+
+      record.send(object_method_name)
+    end
+
+    def include_relationship?(record, serialization_params)
+      if conditional_proc.present?
+        FastJsonapi.call_proc(conditional_proc, record, serialization_params)
+      else
+        true
+      end
+    end
+
+    def serializer_for(record, serialization_params)
+      # TODO: Remove this, dead code...
+      if @static_serializer
+        @static_serializer
+
+      elsif polymorphic
+        name = polymorphic[record.class] if polymorphic.is_a?(Hash)
+        name ||= record.class.name
+        serializer_for_name(name)
+
+      elsif serializer.is_a?(Proc)
+        FastJsonapi.call_proc(serializer, record, serialization_params)
+
+      elsif object_block
+        serializer_for_name(record.class.name)
+
+      else
+        # TODO: Remove this, dead code...
+        raise "Unknown serializer for object #{record.inspect}"
+      end
+    end
+
+    def static_serializer
+      initialize_static_serializer unless @initialized_static_serializer
+      @static_serializer
+    end
+
+    def static_record_type
+      initialize_static_serializer unless @initialized_static_serializer
+      @static_record_type
+    end
+
+    private
+
+    def ids_hash_from_record_and_relationship(record, params = {})
+      initialize_static_serializer unless @initialized_static_serializer
+
+      return ids_hash(fetch_id(record, params), @static_record_type) if @static_record_type
+
+      return unless associated_object = fetch_associated_object(record, params)
+
+      if associated_object.respond_to? :map
+        return associated_object.map do |object|
+          id_hash_from_record object, params
+        end
+      end
+
+      id_hash_from_record associated_object, params
+    end
+
+    def id_hash_from_record(record, params)
+      associated_record_type = record_type_for(record, params)
+      id_hash(record.public_send(id_method_name), associated_record_type)
+    end
+
+    def ids_hash(ids, record_type)
+      return ids.map { |id| id_hash(id, record_type) } if ids.respond_to? :map
+
+      id_hash(ids, record_type) # ids variable is just a single id here
+    end
+
+    def id_hash(id, record_type, default_return = false)
+      if id.present?
+        { id: id.to_s, type: record_type }
+      else
+        default_return ? { id: nil, type: record_type } : nil
+      end
+    end
+
+    def fetch_id(record, params)
+      if object_block.present?
+        object = FastJsonapi.call_proc(object_block, record, params)
+        return object.map { |item| item.public_send(id_method_name) } if object.respond_to? :map
+
+        return object.try(id_method_name)
+      end
+      record.public_send(id_method_name)
+    end
+
+    def add_links_hash(record, params, output_hash)
+      output_hash[key][:links] = if links.is_a?(Symbol)
+                                   record.public_send(links)
+                                 else
+                                   links.each_with_object({}) do |(key, method), hash|
+                                     Link.new(key: key, method: method).serialize(record, params, hash)
+                                   end
+                                 end
+    end
+
+    def add_meta_hash(record, params, output_hash)
+      output_hash[key][:meta] = if meta.is_a?(Proc)
+                                  FastJsonapi.call_proc(meta, record, params)
+                                else
+                                  meta
+                                end
+    end
+
+    def run_key_transform(input)
+      if transform_method.present?
+        input.to_s.send(*transform_method).to_sym
+      else
+        input.to_sym
+      end
+    end
+
+    def initialize_static_serializer
+      return if @initialized_static_serializer
+
+      @static_serializer = compute_static_serializer
+      @static_record_type = compute_static_record_type
+      @initialized_static_serializer = true
+    end
+
+    def compute_static_serializer
+      if polymorphic
+        # polymorphic without a specific serializer --
+        # the serializer is determined on a record-by-record basis
+        nil
+
+      elsif serializer.is_a?(Symbol) || serializer.is_a?(String)
+        # a serializer was explicitly specified by name -- determine the serializer class
+        serializer_for_name(serializer)
+
+      elsif serializer.is_a?(Proc)
+        # the serializer is a Proc to be executed per object -- not static
+        nil
+
+      elsif serializer
+        # something else was specified, e.g. a specific serializer class -- return it
+        serializer
+
+      elsif object_block
+        # an object block is specified without a specific serializer --
+        # assume the objects might be different and infer the serializer by their class
+        nil
+
+      else
+        # no serializer information was provided -- infer it from the relationship name
+        serializer_name = name.to_s
+        serializer_name = serializer_name.singularize if relationship_type.to_sym == :has_many
+        serializer_for_name(serializer_name)
+      end
+    end
+
+    def serializer_for_name(name)
+      @serializers_for_name[name] ||= owner.serializer_for(name)
+    end
+
+    def record_type_for(record, serialization_params)
+      # if the record type is static, return it
+      return @static_record_type if @static_record_type
+
+      # if not, use the record type of the serializer, and memoize the transformed version
+      serializer = serializer_for(record, serialization_params)
+      @record_types_for[serializer] ||= run_key_transform(serializer.record_type)
+    end
+
+    def compute_static_record_type
+      if polymorphic
+        nil
+      elsif record_type
+        run_key_transform(record_type)
+      elsif @static_serializer
+        run_key_transform(@static_serializer.record_type)
+      end
+    end
+  end
+end