sanger-jsonapi-resources 0.1.0

data/lib/jsonapi/formatter.rb

@@ -0,0 +1,169 @@
+module JSONAPI
+  class Formatter
+    class << self
+      def format(arg)
+        arg.to_s
+      end
+
+      def unformat(arg)
+        arg
+      end
+
+      def cached
+        return FormatterWrapperCache.new(self)
+      end
+
+      def uncached
+        return self
+      end
+
+      def formatter_for(format)
+        "#{format.to_s.camelize}Formatter".safe_constantize
+      end
+    end
+  end
+
+  class KeyFormatter < Formatter
+    class << self
+      def format(key)
+        super
+      end
+
+      def unformat(formatted_key)
+        super
+      end
+    end
+  end
+
+  class RouteFormatter < Formatter
+    class << self
+      def format(route)
+        super
+      end
+
+      def unformat(formatted_route)
+        super
+      end
+    end
+  end
+
+  class ValueFormatter < Formatter
+    class << self
+      def format(raw_value)
+        super(raw_value)
+      end
+
+      def unformat(value)
+        super(value)
+      end
+
+      def value_formatter_for(type)
+        "#{type.to_s.camelize}ValueFormatter".safe_constantize
+      end
+    end
+  end
+
+  # Warning: Not thread-safe. Wrap in ThreadLocalVar as needed.
+  class FormatterWrapperCache
+    attr_reader :formatter_klass
+
+    def initialize(formatter_klass)
+      @formatter_klass = formatter_klass
+      @format_cache = NaiveCache.new{|arg| formatter_klass.format(arg) }
+      @unformat_cache = NaiveCache.new{|arg| formatter_klass.unformat(arg) }
+    end
+
+    def format(arg)
+      @format_cache.get(arg)
+    end
+
+    def unformat(arg)
+      @unformat_cache.get(arg)
+    end
+
+    def cached
+      self
+    end
+
+    def uncached
+      return @formatter_klass
+    end
+  end
+end
+
+class UnderscoredKeyFormatter < JSONAPI::KeyFormatter
+end
+
+class CamelizedKeyFormatter < JSONAPI::KeyFormatter
+  class << self
+    def format(key)
+      super.camelize(:lower)
+    end
+
+    def unformat(formatted_key)
+      formatted_key.to_s.underscore
+    end
+  end
+end
+
+class DasherizedKeyFormatter < JSONAPI::KeyFormatter
+  class << self
+    def format(key)
+      super.underscore.dasherize
+    end
+
+    def unformat(formatted_key)
+      formatted_key.to_s.underscore
+    end
+  end
+end
+
+class DefaultValueFormatter < JSONAPI::ValueFormatter
+  class << self
+    def format(raw_value)
+      case raw_value
+        when Date, Time, DateTime, ActiveSupport::TimeWithZone, BigDecimal
+          # Use the as_json methods added to various base classes by ActiveSupport
+          return raw_value.as_json
+        else
+          return raw_value
+      end
+    end
+  end
+end
+
+class IdValueFormatter < JSONAPI::ValueFormatter
+  class << self
+    def format(raw_value)
+      return if raw_value.nil?
+      raw_value.to_s
+    end
+  end
+end
+
+class UnderscoredRouteFormatter < JSONAPI::RouteFormatter
+end
+
+class CamelizedRouteFormatter < JSONAPI::RouteFormatter
+  class << self
+    def format(route)
+      super.camelize(:lower)
+    end
+
+    def unformat(formatted_route)
+      formatted_route.to_s.underscore
+    end
+  end
+end
+
+class DasherizedRouteFormatter < JSONAPI::RouteFormatter
+  class << self
+    def format(route)
+      super.dasherize
+    end
+
+    def unformat(formatted_route)
+      formatted_route.to_s.underscore
+    end
+  end
+end

data/lib/jsonapi/include_directives.rb

@@ -0,0 +1,100 @@
+module JSONAPI
+  class IncludeDirectives
+    # Construct an IncludeDirectives Hash from an array of dot separated include strings.
+    # For example ['posts.comments.tags']
+    # will transform into =>
+    # {
+    #   posts:{
+    #     include:true,
+    #     include_related:{
+    #       comments:{
+    #         include:true,
+    #         include_related:{
+    #           tags:{
+    #             include:true
+    #           }
+    #         }
+    #       }
+    #     }
+    #   }
+    # }
+
+    def initialize(resource_klass, includes_array, force_eager_load: false)
+      @resource_klass = resource_klass
+      @force_eager_load = force_eager_load
+      @include_directives_hash = { include_related: {} }
+      includes_array.each do |include|
+        parse_include(include)
+      end
+    end
+
+    def include_directives
+      @include_directives_hash
+    end
+
+    def model_includes
+      get_includes(@include_directives_hash)
+    end
+
+    def paths
+      delve_paths(get_includes(@include_directives_hash, false))
+    end
+
+    private
+
+    def get_related(current_path)
+      current = @include_directives_hash
+      current_resource_klass = @resource_klass
+      current_path.split('.').each do |fragment|
+        fragment = fragment.to_sym
+
+        if current_resource_klass
+          current_relationship = current_resource_klass._relationships[fragment]
+          current_resource_klass = current_relationship.try(:resource_klass)
+        else
+          warn "[RELATIONSHIP NOT FOUND] Relationship could not be found for #{current_path}."
+        end
+
+        include_in_join = @force_eager_load || !current_relationship || current_relationship.eager_load_on_include
+
+        current[:include_related][fragment] ||= { include: false, include_related: {}, include_in_join: include_in_join }
+        current = current[:include_related][fragment]
+      end
+      current
+    end
+
+    def get_includes(directive, only_joined_includes = true)
+      ir = directive[:include_related]
+      ir = ir.select { |k,v| v[:include_in_join] } if only_joined_includes
+
+      ir.map do |name, sub_directive|
+        sub = get_includes(sub_directive, only_joined_includes)
+        sub.any? ? { name => sub } : name
+      end
+    end
+
+    def parse_include(include)
+      parts = include.split('.')
+      local_path = ''
+
+      parts.each do |name|
+        local_path += local_path.length > 0 ? ".#{name}" : name
+        related = get_related(local_path)
+        related[:include] = true
+      end
+    end
+
+    def delve_paths(obj)
+      case obj
+        when Array
+          obj.map{|elem| delve_paths(elem)}.flatten(1)
+        when Hash
+          obj.map{|k,v| [[k]] + delve_paths(v).map{|path| [k] + path } }.flatten(1)
+        when Symbol, String
+          [[obj]]
+        else
+          raise "delve_paths cannot descend into #{obj.class.name}"
+      end
+    end
+  end
+end

data/lib/jsonapi/link_builder.rb

@@ -0,0 +1,152 @@
+module JSONAPI
+  class LinkBuilder
+    attr_reader :base_url,
+                :primary_resource_klass,
+                :route_formatter,
+                :engine_name
+
+    def initialize(config = {})
+      @base_url               = config[:base_url]
+      @primary_resource_klass = config[:primary_resource_klass]
+      @route_formatter        = config[:route_formatter]
+      @engine_name            = build_engine_name
+
+      # Warning: These make LinkBuilder non-thread-safe. That's not a problem with the
+      # request-specific way it's currently used, though.
+      @resources_path_cache   = JSONAPI::NaiveCache.new do |source_klass|
+        formatted_module_path_from_class(source_klass) + format_route(source_klass._type.to_s)
+      end
+    end
+
+    def engine?
+      !!@engine_name
+    end
+
+    def primary_resources_url
+      if engine?
+        engine_primary_resources_url
+      else
+        regular_primary_resources_url
+      end
+    end
+
+    def query_link(query_params)
+      "#{ primary_resources_url }?#{ query_params.to_query }"
+    end
+
+    def relationships_related_link(source, relationship, query_params = {})
+      url = "#{ self_link(source) }/#{ route_for_relationship(relationship) }"
+      url = "#{ url }?#{ query_params.to_query }" if query_params.present?
+      url
+    end
+
+    def relationships_self_link(source, relationship)
+      "#{ self_link(source) }/relationships/#{ route_for_relationship(relationship) }"
+    end
+
+    def self_link(source)
+      if engine?
+        engine_resource_url(source)
+      else
+        regular_resource_url(source)
+      end
+    end
+
+    private
+
+    def build_engine_name
+      scopes = module_scopes_from_class(primary_resource_klass)
+
+      begin
+        unless scopes.empty?
+          "#{ scopes.first.to_s.camelize }::Engine".safe_constantize
+        end
+      rescue LoadError => e
+        nil
+      end
+    end
+
+    def engine_path_from_resource_class(klass)
+      path_name = engine_resources_path_name_from_class(klass)
+      engine_name.routes.url_helpers.public_send(path_name)
+    end
+
+    def engine_primary_resources_path
+      engine_path_from_resource_class(primary_resource_klass)
+    end
+
+    def engine_primary_resources_url
+      "#{ base_url }#{ engine_primary_resources_path }"
+    end
+
+    def engine_resource_path(source)
+      resource_path_name = engine_resource_path_name_from_source(source)
+      engine_name.routes.url_helpers.public_send(resource_path_name, source.id)
+    end
+
+    def engine_resource_path_name_from_source(source)
+      scopes         = module_scopes_from_class(source.class)[1..-1]
+      base_path_name = scopes.map { |scope| scope.underscore }.join("_")
+      end_path_name  = source.class._type.to_s.singularize
+      [base_path_name, end_path_name, "path"].reject(&:blank?).join("_")
+    end
+
+    def engine_resource_url(source)
+      "#{ base_url }#{ engine_resource_path(source) }"
+    end
+
+    def engine_resources_path_name_from_class(klass)
+      scopes         = module_scopes_from_class(klass)[1..-1]
+      base_path_name = scopes.map { |scope| scope.underscore }.join("_")
+      end_path_name  = klass._type.to_s
+
+      if base_path_name.blank?
+        "#{ end_path_name }_path"
+      else
+        "#{ base_path_name }_#{ end_path_name }_path"
+      end
+    end
+
+    def format_route(route)
+      route_formatter.format(route)
+    end
+
+    def formatted_module_path_from_class(klass)
+      scopes = module_scopes_from_class(klass)
+
+      unless scopes.empty?
+        "/#{ scopes.map{ |scope| format_route(scope.to_s.underscore) }.join('/') }/"
+      else
+        "/"
+      end
+    end
+
+    def module_scopes_from_class(klass)
+      klass.name.to_s.split("::")[0...-1]
+    end
+
+    def regular_resources_path(source_klass)
+      @resources_path_cache.get(source_klass)
+    end
+
+    def regular_primary_resources_path
+      regular_resources_path(primary_resource_klass)
+    end
+
+    def regular_primary_resources_url
+      "#{ base_url }#{ regular_primary_resources_path }"
+    end
+
+    def regular_resource_path(source)
+      "#{regular_resources_path(source.class)}/#{source.id}"
+    end
+
+    def regular_resource_url(source)
+      "#{ base_url }#{ regular_resource_path(source) }"
+    end
+
+    def route_for_relationship(relationship)
+      format_route(relationship.name)
+    end
+  end
+end

data/lib/jsonapi/mime_types.rb

@@ -0,0 +1,41 @@
+require 'json'
+
+module JSONAPI
+  MEDIA_TYPE = 'application/vnd.api+json'
+
+  module MimeTypes
+    def self.install
+      Mime::Type.register JSONAPI::MEDIA_TYPE, :api_json
+
+      # :nocov:
+      if Rails::VERSION::MAJOR >= 5
+        parsers = ActionDispatch::Request.parameter_parsers.merge(
+          Mime::Type.lookup(JSONAPI::MEDIA_TYPE).symbol => parser
+        )
+        ActionDispatch::Request.parameter_parsers = parsers
+      else
+        ActionDispatch::ParamsParser::DEFAULT_PARSERS[Mime::Type.lookup(JSONAPI::MEDIA_TYPE)] = parser
+      end
+      # :nocov:
+    end
+
+    def self.parser
+      lambda do |body|
+        begin
+          data = JSON.parse(body)
+          if data.is_a?(Hash)
+            data.with_indifferent_access
+          else
+            fail JSONAPI::Exceptions::InvalidRequestFormat.new
+          end
+        rescue JSON::ParserError => e
+          { _parser_exception: JSONAPI::Exceptions::BadRequest.new(e.to_s)  }
+        rescue => e
+          { _parser_exception: e }
+        end
+      end
+    end
+  end
+
+  MimeTypes.install
+end

data/lib/jsonapi/naive_cache.rb

@@ -0,0 +1,30 @@
+module JSONAPI
+
+  # Cache which memoizes the given block.
+  #
+  # It's "naive" because it clears the least-recently-inserted cache entry
+  # rather than the least-recently-used. This makes lookups faster but cache
+  # misses more frequent after cleanups. Therefore you the best time to use
+  # this cache is when you expect only a small number of unique lookup keys, so
+  # that the cache never has to clear.
+  #
+  # Also, it's not thread safe (although jsonapi-resources is careful to only
+  # use it in a thread safe way).
+  class NaiveCache
+    def initialize(cap = 10000, &calculator)
+      @cap = cap
+      @data = {}
+      @calculator = calculator
+    end
+
+    def get(key)
+      found = true
+      value = @data.fetch(key) { found = false }
+      return value if found
+      value = @calculator.call(key)
+      @data[key] = value
+      @data.shift if @data.length > @cap
+      return value
+    end
+  end
+end

data/lib/jsonapi/operation.rb

@@ -0,0 +1,24 @@
+module JSONAPI
+  class Operation
+    attr_reader :resource_klass, :operation_type, :options
+
+    def initialize(operation_type, resource_klass, options)
+      @operation_type = operation_type
+      @resource_klass = resource_klass
+      @options = options
+    end
+
+    def transactional?
+      JSONAPI::Processor._processor_from_resource_type(resource_klass).transactional_operation_type?(operation_type)
+    end
+
+    def process
+      processor.process
+    end
+
+    private
+    def processor
+      JSONAPI::Processor.processor_instance_for(resource_klass, operation_type, options)
+    end
+  end
+end

data/lib/jsonapi/operation_dispatcher.rb

@@ -0,0 +1,88 @@
+module JSONAPI
+  class OperationDispatcher
+
+    def initialize(transaction: lambda { |&block| block.yield },
+                   rollback: lambda { },
+                   server_error_callbacks: [])
+
+      @transaction = transaction
+      @rollback = rollback
+      @server_error_callbacks = server_error_callbacks
+    end
+
+    def process(operations)
+      results = JSONAPI::OperationResults.new
+
+      # Use transactions if more than one operation and if one of the operations can be transactional
+      # Even if transactional transactions won't be used unless the derived OperationsProcessor supports them.
+      transactional = false
+
+      operations.each do |operation|
+        transactional |= operation.transactional?
+      end if JSONAPI.configuration.allow_transactions
+
+      transaction(transactional) do
+        # Links and meta data global to the set of operations
+        operations_meta = {}
+        operations_links = {}
+        operations.each do |operation|
+          results.add_result(process_operation(operation))
+          rollback(transactional) if results.has_errors?
+        end
+        results.meta = operations_meta
+        results.links = operations_links
+      end
+      results
+    end
+
+    private
+
+    def transaction(transactional)
+      if transactional
+        @transaction.call do
+          yield
+        end
+      else
+        yield
+      end
+    end
+
+    def rollback(transactional)
+      if transactional
+        @rollback.call
+      end
+    end
+
+    def process_operation(operation)
+      with_default_handling do 
+        operation.process
+      end        
+    end
+
+    def with_default_handling(&block)
+      block.yield
+    rescue => e
+      if JSONAPI.configuration.exception_class_whitelisted?(e)
+        raise e
+      else
+        @server_error_callbacks.each { |callback|
+          safe_run_callback(callback, e)
+        }
+
+        internal_server_error = JSONAPI::Exceptions::InternalServerError.new(e)
+        Rails.logger.error { "Internal Server Error: #{e.message} #{e.backtrace.join("\n")}" }
+        return JSONAPI::ErrorsOperationResult.new(internal_server_error.errors[0].code, internal_server_error.errors)
+      end
+    end
+
+    def safe_run_callback(callback, error)
+      begin 
+        callback.call(error)
+      rescue => e
+        Rails.logger.error { "Error in error handling callback: #{e.message} #{e.backtrace.join("\n")}" }
+        internal_server_error = JSONAPI::Exceptions::InternalServerError.new(e)
+        return JSONAPI::ErrorsOperationResult.new(internal_server_error.errors[0].code, internal_server_error.errors)
+      end
+    end
+  end
+end

data/lib/jsonapi/operation_result.rb

@@ -0,0 +1,65 @@
+module JSONAPI
+  class OperationResult
+    attr_accessor :code
+    attr_accessor :meta
+    attr_accessor :links
+    attr_accessor :options
+
+    def initialize(code, options = {})
+      @code = code
+      @options = options
+      @meta = options.fetch(:meta, {})
+      @links = options.fetch(:links, {})
+    end
+  end
+
+  class ErrorsOperationResult < OperationResult
+    attr_accessor :errors
+
+    def initialize(code, errors, options = {})
+      @errors = errors
+      super(code, options)
+    end
+  end
+
+  class ResourceOperationResult < OperationResult
+    attr_accessor :resource
+
+    def initialize(code, resource, options = {})
+      @resource = resource
+      super(code, options)
+    end
+  end
+
+  class ResourcesOperationResult < OperationResult
+    attr_accessor :resources, :pagination_params, :record_count, :page_count
+
+    def initialize(code, resources, options = {})
+      @resources = resources
+      @pagination_params = options.fetch(:pagination_params, {})
+      @record_count = options[:record_count]
+      @page_count = options[:page_count]
+      super(code, options)
+    end
+  end
+
+  class RelatedResourcesOperationResult < ResourcesOperationResult
+    attr_accessor :source_resource, :_type
+
+    def initialize(code, source_resource, type, resources, options = {})
+      @source_resource = source_resource
+      @_type = type
+      super(code, resources, options)
+    end
+  end
+
+  class LinksObjectOperationResult < OperationResult
+    attr_accessor :parent_resource, :relationship
+
+    def initialize(code, parent_resource, relationship, options = {})
+      @parent_resource = parent_resource
+      @relationship = relationship
+      super(code, options)
+    end
+  end
+end

data/lib/jsonapi/operation_results.rb

@@ -0,0 +1,35 @@
+module JSONAPI
+  class OperationResults
+    attr_accessor :results
+    attr_accessor :meta
+    attr_accessor :links
+
+    def initialize
+      @results = []
+      @has_errors = false
+      @meta = {}
+      @links = {}
+    end
+
+    def add_result(result)
+      @has_errors = true if result.is_a?(JSONAPI::ErrorsOperationResult)
+      @results.push(result)
+    end
+
+    def has_errors?
+      @has_errors
+    end
+
+    def all_errors
+      errors = []
+      if @has_errors
+        @results.each do |result|
+          if result.is_a?(JSONAPI::ErrorsOperationResult)
+            errors.concat(result.errors)
+          end
+        end
+      end
+      errors
+    end
+  end
+end