joyful_jsonapi 0.0.1

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/generators/serializer/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Generates a serializer for the given model.
+
+Example:
+    rails generate serializer Movie
+
+    This will create:
+        app/serializers/movie_serializer.rb

data/lib/generators/serializer/serializer_generator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rails/generators/base'
+
+class SerializerGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path('templates', __dir__)
+
+  argument :attributes, type: :array, default: [], banner: 'field field'
+
+  def create_serializer_file
+    template 'serializer.rb.tt', File.join('app', 'serializers', class_path, "#{file_name}_serializer.rb")
+  end
+
+  private
+
+    def attributes_names
+      attributes.map { |a| a.name.to_sym.inspect }
+    end
+end

data/lib/generators/serializer/templates/serializer.rb.tt

@@ -0,0 +1,6 @@
+<% module_namespacing do -%>
+class <%= class_name %>Serializer
+  include JoyfulJsonapi::ObjectSerializer
+  attributes <%= attributes_names.join(", ") %>
+end
+<% end -%>

data/lib/joyful_jsonapi.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module JoyfulJsonapi
+  require 'joyful_jsonapi/object_serializer'
+  require 'joyful_jsonapi/error_serializer'
+  if defined?(::Rails)
+    require 'joyful_jsonapi/railtie'
+  elsif defined?(::ActiveRecord)
+    require 'extensions/has_one'
+  end
+end

data/lib/joyful_jsonapi/attribute.rb

@@ -0,0 +1,29 @@
+module JoyfulJsonapi
+  class Attribute
+    attr_reader :key, :method, :conditional_proc
+
+    def initialize(key:, method:, options: {})
+      @key = key
+      @method = method
+      @conditional_proc = options[:if]
+    end
+
+    def serialize(record, serialization_params, output_hash)
+      if include_attribute?(record, serialization_params)
+        output_hash[key] = if method.is_a?(Proc)
+          method.arity.abs == 1 ? method.call(record) : method.call(record, serialization_params)
+        else
+          record.public_send(method)
+        end
+      end
+    end
+
+    def include_attribute?(record, serialization_params)
+      if conditional_proc.present?
+        conditional_proc.call(record, serialization_params)
+      else
+        true
+      end
+    end
+  end
+end

data/lib/joyful_jsonapi/error_serializer.rb

@@ -0,0 +1,41 @@
+
+module JoyfulJsonapi
+  class ErrorSerializer
+
+    def initialize(model)
+      @model = model
+      @model.valid?
+    end
+
+    def serializable_hash
+      { errors: errors_for(@model) }
+    end
+
+    def serialized_json(options = nil)
+      serializable_hash.to_json(options)
+    end
+
+    private
+
+    def errors_for(resource)
+      resource.errors.messages.flat_map do |field, errors|
+        build_hashes_for(field, errors)
+      end
+    end
+
+    def build_hashes_for(field, errors)
+      errors.map do |error_message|
+        build_hash_for(field, error_message)
+      end.flatten
+    end
+
+    def build_hash_for(field, error_message)
+      {}.tap do |hash|
+        hash[:status] = "422"
+        hash[:source] = { pointer: "/data/attributes/#{field}" }
+        hash[:detail] = error_message
+      end
+    end
+
+  end
+end

data/lib/joyful_jsonapi/instrumentation.rb

@@ -0,0 +1,2 @@
+require 'joyful_jsonapi/instrumentation/serializable_hash'
+require 'joyful_jsonapi/instrumentation/serialized_json'

data/lib/joyful_jsonapi/instrumentation/serializable_hash.rb

@@ -0,0 +1,15 @@
+require 'active_support/notifications'
+
+module JoyfulJsonapi
+  module ObjectSerializer
+
+    alias_method :serializable_hash_without_instrumentation, :serializable_hash
+
+    def serializable_hash
+      ActiveSupport::Notifications.instrument(SERIALIZABLE_HASH_NOTIFICATION, { name: self.class.name }) do
+        serializable_hash_without_instrumentation
+      end
+    end
+
+  end
+end

data/lib/joyful_jsonapi/instrumentation/serialized_json.rb

@@ -0,0 +1,15 @@
+require 'active_support/notifications'
+
+module JoyfulJsonapi
+  module ObjectSerializer
+
+    alias_method :serialized_json_without_instrumentation, :serialized_json
+
+    def serialized_json
+      ActiveSupport::Notifications.instrument(SERIALIZED_JSON_NOTIFICATION, { name: self.class.name }) do
+        serialized_json_without_instrumentation
+      end
+    end
+
+  end
+end

data/lib/joyful_jsonapi/instrumentation/skylight.rb

@@ -0,0 +1,2 @@
+require 'joyful_jsonapi/instrumentation/skylight/normalizers/serializable_hash'
+require 'joyful_jsonapi/instrumentation/skylight/normalizers/serialized_json'

data/lib/joyful_jsonapi/instrumentation/skylight/normalizers/base.rb

@@ -0,0 +1,7 @@
+require 'skylight'
+
+SKYLIGHT_NORMALIZER_BASE_CLASS = begin
+  ::Skylight::Core::Normalizers::Normalizer
+rescue NameError
+  ::Skylight::Normalizers::Normalizer
+end

data/lib/joyful_jsonapi/instrumentation/skylight/normalizers/serializable_hash.rb

@@ -0,0 +1,22 @@
+require 'joyful_jsonapi/instrumentation/skylight/normalizers/base'
+require 'joyful_jsonapi/instrumentation/serializable_hash'
+
+module JoyfulJsonapi
+  module Instrumentation
+    module Skylight
+      module Normalizers
+        class SerializableHash < SKYLIGHT_NORMALIZER_BASE_CLASS
+
+          register JoyfulJsonapi::ObjectSerializer::SERIALIZABLE_HASH_NOTIFICATION
+
+          CAT = "view.#{JoyfulJsonapi::ObjectSerializer::SERIALIZABLE_HASH_NOTIFICATION}".freeze
+
+          def normalize(trace, name, payload)
+            [ CAT, payload[:name], nil ]
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/joyful_jsonapi/instrumentation/skylight/normalizers/serialized_json.rb

@@ -0,0 +1,22 @@
+require 'joyful_jsonapi/instrumentation/skylight/normalizers/base'
+require 'joyful_jsonapi/instrumentation/serializable_hash'
+
+module JoyfulJsonapi
+  module Instrumentation
+    module Skylight
+      module Normalizers
+        class SerializedJson < SKYLIGHT_NORMALIZER_BASE_CLASS
+
+          register JoyfulJsonapi::ObjectSerializer::SERIALIZED_JSON_NOTIFICATION
+
+          CAT = "view.#{JoyfulJsonapi::ObjectSerializer::SERIALIZED_JSON_NOTIFICATION}".freeze
+
+          def normalize(trace, name, payload)
+            [ CAT, payload[:name], nil ]
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/joyful_jsonapi/link.rb

@@ -0,0 +1,18 @@
+module JoyfulJsonapi
+  class Link
+    attr_reader :key, :method
+
+    def initialize(key:, method:)
+      @key = key
+      @method = method
+    end
+
+    def serialize(record, serialization_params, output_hash)
+      output_hash[key] = if method.is_a?(Proc)
+        method.arity == 1 ? method.call(record) : method.call(record, serialization_params)
+      else
+        record.public_send(method)
+      end
+    end
+  end
+end

data/lib/joyful_jsonapi/multi_to_json.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+# Usage:
+#   class Movie
+#     def to_json(payload)
+#       JoyfulJsonapi::MultiToJson.to_json(payload)
+#     end
+#   end
+module JoyfulJsonapi
+  module MultiToJson
+    # Result object pattern is from https://johnnunemaker.com/resilience-in-ruby/
+    # e.g. https://github.com/github/github-ds/blob/fbda5389711edfb4c10b6c6bad19311dfcb1bac1/lib/github/result.rb
+    class Result
+      def initialize(*rescued_exceptions)
+        @rescued_exceptions = if rescued_exceptions.empty?
+          [StandardError]
+        else
+          rescued_exceptions
+        end
+
+        @value = yield
+        @error = nil
+      rescue *rescued_exceptions => e
+        @error = e
+      end
+
+      def ok?
+        @error.nil?
+      end
+
+      def value!
+        if ok?
+          @value
+        else
+          raise @error
+        end
+      end
+
+      def rescue
+        return self if ok?
+
+        Result.new(*@rescued_exceptions) { yield(@error) }
+      end
+    end
+
+    def self.logger(device=nil)
+      return @logger = Logger.new(device) if device
+      @logger ||= Logger.new(IO::NULL)
+    end
+
+    # Encoder-compatible with default MultiJSON adapters and defaults
+    def self.to_json_method
+      encode_method = String.new(%(def _fast_to_json(object)\n ))
+      encode_method << Result.new(LoadError) {
+        require 'oj'
+        %(::Oj.dump(object, mode: :compat, time_format: :ruby, use_to_json: true))
+      }.rescue {
+        require 'yajl'
+        %(::Yajl::Encoder.encode(object))
+      }.rescue {
+        require 'jrjackson' unless defined?(::JrJackson)
+        %(::JrJackson::Json.dump(object))
+      }.rescue {
+        require 'json'
+        %(JSON.fast_generate(object, create_additions: false, quirks_mode: true))
+      }.rescue {
+        require 'gson'
+        %(::Gson::Encoder.new({}).encode(object))
+      }.rescue {
+        require 'active_support/json/encoding'
+        %(::ActiveSupport::JSON.encode(object))
+      }.rescue {
+        warn "No JSON encoder found. Falling back to `object.to_json`"
+        %(object.to_json)
+      }.value!
+      encode_method << "\nend"
+    end
+
+    def self.to_json(object)
+      _fast_to_json(object)
+    rescue NameError
+      define_to_json(JoyfulJsonapi::MultiToJson)
+      _fast_to_json(object)
+    end
+
+    def self.define_to_json(receiver)
+      cl = caller_locations[0]
+      method_body = to_json_method
+      logger.debug { "Defining #{receiver}._fast_to_json as #{method_body.inspect}" }
+      receiver.instance_eval method_body, cl.absolute_path, cl.lineno
+    end
+
+    def self.reset_to_json!
+      undef :_fast_to_json if method_defined?(:_fast_to_json)
+      logger.debug { "Undefining #{receiver}._fast_to_json" }
+    end
+  end
+end

data/lib/joyful_jsonapi/object_serializer.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+require 'active_support/time'
+require 'active_support/json'
+require 'active_support/concern'
+require 'active_support/inflector'
+require 'active_support/core_ext/numeric/time'
+require 'joyful_jsonapi/attribute'
+require 'joyful_jsonapi/relationship'
+require 'joyful_jsonapi/link'
+require 'joyful_jsonapi/serialization_core'
+
+module JoyfulJsonapi
+  module ObjectSerializer
+    extend ActiveSupport::Concern
+    include SerializationCore
+
+    SERIALIZABLE_HASH_NOTIFICATION = 'render.joyful_jsonapi.serializable_hash'
+    SERIALIZED_JSON_NOTIFICATION = 'render.joyful_jsonapi.serialized_json'
+
+    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
+      return hash_for_collection if is_collection?(@resource, @is_collection)
+
+      hash_for_one_record
+    end
+    alias_method :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], @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, @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
+
+    def serialized_json
+      ActiveSupport::JSON.encode(serializable_hash)
+    end
+
+    private
+
+    def process_options(options)
+      @fieldsets = deep_symbolize(options[:fields].presence || {})
+      @params = {}
+
+      return if options.blank?
+
+      @known_included_objects = {}
+      @meta = options[:meta]
+      @links = options[:links]
+      @is_collection = options[:is_collection]
+      @params = options[:params] || {}
+      raise ArgumentError.new("`params` option passed to serializer must be a hash") unless @params.is_a?(Hash)
+
+      if options[:include].present?
+        @includes = options[:include].delete_if(&:blank?).map(&:to_sym)
+        self.class.validate_includes!(@includes)
+      end
+    end
+
+    def deep_symbolize(collection)
+      if collection.is_a? Hash
+        Hash[collection.map do |k, v|
+          [k.to_sym, deep_symbolize(v)]
+        end]
+      elsif collection.is_a? Array
+        collection.map { |i| deep_symbolize(i) }
+      else
+        collection.to_sym
+      end
+    end
+
+    def is_collection?(resource, force_is_collection = nil)
+      return force_is_collection unless force_is_collection.nil?
+
+      resource.respond_to?(:size) && !resource.respond_to?(:each_pair)
+    end
+
+    class_methods do
+
+      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.cache_length = cache_length
+        subclass.race_condition_ttl = race_condition_ttl
+        subclass.data_links = data_links.dup if data_links.present?
+        subclass.cached = cached
+        subclass.set_type(subclass.reflected_record_type) if subclass.reflected_record_type
+        subclass.meta_to_serialize = meta_to_serialize
+      end
+
+      def reflected_record_type
+        return @reflected_record_type if defined?(@reflected_record_type)
+
+        @reflected_record_type ||= begin
+          if self.name.end_with?('Serializer')
+            self.name.split('::').last.chomp('Serializer').underscore.to_sym
+          end
+        end
+      end
+
+      def set_key_transform(transform_name)
+        mapping = {
+          camel: :camelize,
+          camel_lower: [:camelize, :lower],
+          dash: :dasherize,
+          underscore: :underscore
+        }
+        self.transform_method = mapping[transform_name.to_sym]
+
+        # ensure that the record type is correctly transformed
+        if record_type
+          set_type(record_type)
+        elsif reflected_record_type
+          set_type(reflected_record_type)
+        end
+      end
+
+      def run_key_transform(input)
+        if self.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 joyful_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 cache_options(cache_options)
+        self.cached = cache_options[:enabled] || false
+        self.cache_length = cache_options[:cache_length] || 5.minutes
+        self.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 self.attributes_to_serialize.nil?
+
+        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?
+
+        if !relationship.cached
+          self.uncachable_relationships_to_serialize[relationship.name] = relationship
+        else
+          self.cachable_relationships_to_serialize[relationship.name] = relationship
+        end
+        self.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(&block)
+        self.meta_to_serialize = block
+      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
+          base_key_sym = base_serialization_key.to_sym
+          id_postfix = '_ids'
+        else
+          base_serialization_key = base_key
+          base_key_sym = name
+          id_postfix = '_id'
+        end
+        Relationship.new(
+          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,
+            block
+          ),
+          record_type: options[:record_type] || run_key_transform(base_key_sym),
+          object_method_name: options[:object_method_name] || name,
+          object_block: block,
+          serializer: compute_serializer_name(options[:serializer] || base_key_sym),
+          relationship_type: relationship_type,
+          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]
+        )
+      end
+
+      def compute_id_method_name(custom_id_method_name, id_method_name_from_relationship, block)
+        if block.present?
+          custom_id_method_name || :id
+        else
+          custom_id_method_name || id_method_name_from_relationship
+        end
+      end
+
+      def compute_serializer_name(serializer_key)
+        return serializer_key unless serializer_key.is_a? Symbol
+        namespace = self.name.gsub(/()?\w+Serializer$/, '')
+        serializer_name = serializer_key.to_s.classify + 'Serializer'
+        (namespace + serializer_name).to_sym
+      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)
+        self.data_links = {} if self.data_links.nil?
+        link_method_name = link_name if link_method_name.nil?
+        key = run_key_transform(link_name)
+
+        self.data_links[key] = Link.new(
+          key: key,
+          method: block || link_method_name
+        )
+      end
+
+      def validate_includes!(includes)
+        return if includes.blank?
+
+        includes.detect do |include_item|
+          klass = self
+          parse_include_item(include_item).each do |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
+            klass = relationship_to_include.serializer.to_s.constantize unless relationship_to_include.polymorphic.is_a?(Hash)
+          end
+        end
+      end
+    end
+  end
+end