jsonapi-resources 0.8.3 → 0.9.0.beta1

data/lib/jsonapi-resources.rb

@@ -1,5 +1,7 @@
 require 'jsonapi/naive_cache'
+require 'jsonapi/compiled_json'
 require 'jsonapi/resource'
+require 'jsonapi/cached_resource_fragment'
 require 'jsonapi/response_document'
 require 'jsonapi/acts_as_resource_controller'
 require 'jsonapi/resource_controller'

data/lib/jsonapi/acts_as_resource_controller.rb

@@ -2,14 +2,12 @@ require 'csv'
 
 module JSONAPI
   module ActsAsResourceController
-    MEDIA_TYPE_MATCHER = /(.+".+"[^,]*|[^,]+)/
+    MEDIA_TYPE_MATCHER = /.+".+"[^,]*|[^,]+/
     ALL_MEDIA_TYPES = '*/*'
 
     def self.included(base)
       base.extend ClassMethods
       base.include Callbacks
-      base.before_action :ensure_correct_media_type, only: [:create, :update, :create_relationship, :update_relationship]
-      base.before_action :ensure_valid_accept_media_type
       base.cattr_reader :server_error_callbacks
       base.define_jsonapi_resources_callbacks :process_operations
     end
@@ -27,18 +25,22 @@ module JSONAPI
     end
 
     def create
+      return unless verify_content_type_header
       process_request
     end
 
     def create_relationship
+      return unless verify_content_type_header
       process_request
     end
 
     def update_relationship
+      return unless verify_content_type_header
       process_request
     end
 
     def update
+      return unless verify_content_type_header
       process_request
     end
 
@@ -59,23 +61,29 @@ module JSONAPI
     end
 
     def process_request
+      return unless verify_accept_header
+
       @request = JSONAPI::RequestParser.new(params, context: context,
                                             key_formatter: key_formatter,
                                             server_error_callbacks: (self.class.server_error_callbacks || []))
+
       unless @request.errors.empty?
         render_errors(@request.errors)
       else
-        process_operations
-        render_results(@operation_results)
+        operations = @request.operations
+        unless JSONAPI.configuration.resource_cache.nil?
+          operations.each {|op| op.options[:cache_serializer] = resource_serializer }
+        end
+        results = process_operations(operations)
+        render_results(results)
       end
-
     rescue => e
       handle_exceptions(e)
     end
 
-    def process_operations
+    def process_operations(operations)
       run_callbacks :process_operations do
-        @operation_results = operation_dispatcher.process(@request.operations)
+        operation_dispatcher.process(operations)
       end
     end
 
@@ -109,6 +117,19 @@ module JSONAPI
       @resource_serializer_klass ||= JSONAPI::ResourceSerializer
     end
 
+    def resource_serializer
+      @resource_serializer ||= resource_serializer_klass.new(
+        resource_klass,
+        include_directives: @request ? @request.include_directives : nil,
+        fields: @request ? @request.fields : {},
+        base_url: base_url,
+        key_formatter: key_formatter,
+        route_formatter: route_formatter,
+        serialization_options: serialization_options
+      )
+      @resource_serializer
+    end
+
     def base_url
       @base_url ||= request.protocol + request.host_with_port
     end
@@ -117,34 +138,38 @@ module JSONAPI
       @resource_klass_name ||= "#{self.class.name.underscore.sub(/_controller$/, '').singularize}_resource".camelize
     end
 
-    def ensure_correct_media_type
+    def verify_content_type_header
       unless request.content_type == JSONAPI::MEDIA_TYPE
         fail JSONAPI::Exceptions::UnsupportedMediaTypeError.new(request.content_type)
       end
+      true
     rescue => e
       handle_exceptions(e)
+      false
     end
 
-    def ensure_valid_accept_media_type
+    def verify_accept_header
       unless valid_accept_media_type?
         fail JSONAPI::Exceptions::NotAcceptableError.new(request.accept)
       end
+      true
     rescue => e
       handle_exceptions(e)
+      false
     end
 
     def valid_accept_media_type?
       media_types = media_types_for('Accept')
 
       media_types.blank? ||
-          media_types.any? do |media_type|
-            (media_type == JSONAPI::MEDIA_TYPE || media_type == ALL_MEDIA_TYPES)
-          end
+        media_types.any? do |media_type|
+          (media_type == JSONAPI::MEDIA_TYPE || media_type.start_with?(ALL_MEDIA_TYPES))
+        end
     end
 
     def media_types_for(header)
       (request.headers[header] || '')
-        .match(MEDIA_TYPE_MATCHER)
+        .scan(MEDIA_TYPE_MATCHER)
         .to_a
         .map(&:strip)
     end
@@ -198,34 +223,36 @@ module JSONAPI
 
     def render_results(operation_results)
       response_doc = create_response_document(operation_results)
+      content = response_doc.contents
 
-      render_options = {
-        status: response_doc.status,
-        json:   response_doc.contents,
-        content_type: JSONAPI::MEDIA_TYPE
-      }
+      render_options = {}
+      if operation_results.has_errors?
+        render_options[:json] = content
+      else
+        # Bypasing ActiveSupport allows us to use CompiledJson objects for cached response fragments
+        render_options[:body] = JSON.generate(content)
+      end
 
-      render_options[:location] = response_doc.contents[:data]["links"][:self] if (
-        response_doc.status == :created && response_doc.contents[:data].class != Array
+      render_options[:location] = content[:data]["links"][:self] if (
+        response_doc.status == :created && content[:data].class != Array
       )
 
+      # For whatever reason, `render` ignores :status and :content_type when :body is set.
+      # But, we can just set those values directly in the Response object instead.
+      response.status = response_doc.status
+      response.headers['Content-Type'] = JSONAPI::MEDIA_TYPE
+
       render(render_options)
     end
 
     def create_response_document(operation_results)
       JSONAPI::ResponseDocument.new(
         operation_results,
-        primary_resource_klass: resource_klass,
-        include_directives: @request ? @request.include_directives : nil,
-        fields: @request ? @request.fields : nil,
-        base_url: base_url,
+        operation_results.has_errors? ? nil : resource_serializer,
         key_formatter: key_formatter,
-        route_formatter: route_formatter,
         base_meta: base_meta,
         base_links: base_response_links,
-        resource_serializer_klass: resource_serializer_klass,
-        request: @request,
-        serialization_options: serialization_options
+        request: @request
       )
     end
 
@@ -239,6 +266,10 @@ module JSONAPI
         if JSONAPI.configuration.exception_class_whitelisted?(e)
           fail e
         else
+          (self.class.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")}" }
           render_errors(internal_server_error.errors)
@@ -246,6 +277,16 @@ module JSONAPI
       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)
+        render_errors(internal_server_error.errors)
+      end
+    end
+
     # Pass in a methods or a block to be run when an exception is
     # caught that is not a JSONAPI::Exceptions::Error
     # Useful for additional logging or notification configuration that

data/lib/jsonapi/cached_resource_fragment.rb

@@ -0,0 +1,119 @@
+module JSONAPI
+  class CachedResourceFragment
+    def self.fetch_fragments(resource_klass, serializer, context, cache_ids)
+      serializer_config_key = serializer.config_key(resource_klass).gsub("/", "_")
+      context_json = resource_klass.attribute_caching_context(context).to_json
+      context_b64 = JSONAPI.configuration.resource_cache_digest_function.call(context_json)
+      context_key = "ATTR-CTX-#{context_b64.gsub("/", "_")}"
+
+      results = self.lookup(resource_klass, serializer_config_key, context_key, cache_ids)
+
+      miss_ids = results.select{|k,v| v.nil? }.keys
+      unless miss_ids.empty?
+        find_filters = {resource_klass._primary_key => miss_ids.uniq}
+        find_options = {context: context}
+        resource_klass.find(find_filters, find_options).each do |resource|
+          (id, cr) = write(resource_klass, resource, serializer, serializer_config_key, context_key)
+          results[id] = cr
+        end
+      end
+
+      if JSONAPI.configuration.resource_cache_usage_report_function
+        JSONAPI.configuration.resource_cache_usage_report_function.call(
+          resource_klass.name,
+          cache_ids.size - miss_ids.size,
+          miss_ids.size
+        )
+      end
+
+      return results
+    end
+
+    def self.from_cache_value(resource_klass, h)
+      new(
+        resource_klass,
+        h.fetch(:id),
+        h.fetch(:type),
+        h.fetch(:fetchable),
+        h.fetch(:rels, nil),
+        h.fetch(:links, nil),
+        h.fetch(:attrs, nil),
+        h.fetch(:meta, nil)
+      )
+    end
+
+    attr_reader :resource_klass, :id, :type, :fetchable_fields, :relationships,
+                :links_json, :attributes_json, :meta_json,
+                :preloaded_fragments
+
+    def initialize(resource_klass, id, type, fetchable_fields, relationships,
+                   links_json, attributes_json, meta_json)
+      @resource_klass = resource_klass
+      @id = id
+      @type = type
+      @fetchable_fields = Set.new(fetchable_fields)
+
+      # Relationships left uncompiled because we'll often want to insert included ids on retrieval
+      @relationships = relationships
+
+      @links_json = CompiledJson.of(links_json)
+      @attributes_json = CompiledJson.of(attributes_json)
+      @meta_json = CompiledJson.of(meta_json)
+
+      # A hash of hashes
+      @preloaded_fragments ||= Hash.new
+    end
+
+    def to_cache_value
+      {
+        id: id,
+        type: type,
+        fetchable: fetchable_fields,
+        rels: relationships,
+        links: links_json.try(:to_s),
+        attrs: attributes_json.try(:to_s),
+        meta: meta_json.try(:to_s)
+      }
+    end
+
+    private
+
+    def self.lookup(resource_klass, serializer_config_key, context_key, cache_ids)
+      type = resource_klass._type
+
+      keys = cache_ids.map do |(id, cache_key)|
+        [type, id, cache_key, serializer_config_key, context_key]
+      end
+
+      hits = JSONAPI.configuration.resource_cache.read_multi(*keys).reject{|_,v| v.nil? }
+      return keys.each_with_object({}) do |key, hash|
+        (_, id, _, _) = key
+        if hits.has_key?(key)
+          hash[id] = self.from_cache_value(resource_klass, hits[key])
+        else
+          hash[id] = nil
+        end
+      end
+    end
+
+    def self.write(resource_klass, resource, serializer, serializer_config_key, context_key)
+      (id, cache_key) = resource.cache_id
+      json = serializer.object_hash(resource) # No inclusions passed to object_hash
+      cr = self.new(
+        resource_klass,
+        json['id'],
+        json['type'],
+        resource.fetchable_fields,
+        json['relationships'],
+        json['links'],
+        json['attributes'],
+        json['meta']
+      )
+
+      key = [resource_klass._type, id, cache_key, serializer_config_key, context_key]
+      JSONAPI.configuration.resource_cache.write(key, cr.to_cache_value)
+      return [id, cr]
+    end
+
+  end
+end

data/lib/jsonapi/compiled_json.rb

@@ -0,0 +1,36 @@
+module JSONAPI
+  class CompiledJson
+    def self.compile(h)
+      new(JSON.generate(h), h)
+    end
+
+    def self.of(obj)
+      case obj
+        when NilClass then nil
+        when CompiledJson then obj
+        when String then CompiledJson.new(obj)
+        when Hash then CompiledJson.compile(obj)
+        else raise "Can't figure out how to turn #{obj.inspect} into CompiledJson"
+      end
+    end
+
+    def initialize(json, h = nil)
+      @json = json
+      @h = h
+    end
+
+    def to_json(*args)
+      @json
+    end
+
+    def to_s
+      @json
+    end
+
+    def to_h
+      @h ||= JSON.parse(@json)
+    end
+
+    undef_method :as_json
+  end
+end

data/lib/jsonapi/configuration.rb

@@ -22,11 +22,17 @@ module JSONAPI
                 :top_level_meta_include_page_count,
                 :top_level_meta_page_count_key,
                 :allow_transactions,
+                :include_backtraces_in_errors,
                 :exception_class_whitelist,
+                :whitelist_all_exceptions,
                 :always_include_to_one_linkage_data,
                 :always_include_to_many_linkage_data,
                 :cache_formatters,
-                :use_relationship_reflection
+                :use_relationship_reflection,
+                :resource_cache,
+                :default_resource_cache_field,
+                :resource_cache_digest_function,
+                :resource_cache_usage_report_function
 
     def initialize
       #:underscored_key, :camelized_key, :dasherized_key, or custom
@@ -64,6 +70,10 @@ module JSONAPI
 
       self.use_text_errors = false
 
+      # Whether or not to include exception backtraces in JSONAPI error
+      # responses.  Defaults to `false` in production, and `true` otherwise.
+      self.include_backtraces_in_errors = !Rails.env.production?
+
       # List of classes that should not be rescued by the operations processor.
       # For example, if you use Pundit for authorization, you might
       # raise a Pundit::NotAuthorizedError at some point during operations
@@ -72,6 +82,10 @@ module JSONAPI
       # the `Pundit::NotAuthorizedError` to the `exception_class_whitelist`.
       self.exception_class_whitelist = []
 
+      # If enabled, will override configuration option `exception_class_whitelist`
+      # and whitelist all exceptions.
+      self.whitelist_all_exceptions = false
+
       # Resource Linkage
       # Controls the serialization of resource linkage for non compound documents
       # NOTE: always_include_to_many_linkage_data is not currently implemented
@@ -88,12 +102,35 @@ module JSONAPI
 
       # Formatter Caching
       # Set to false to disable caching of string operations on keys and links.
+      # Note that unlike the resource cache, formatter caching is always done
+      # internally in-memory and per-thread; no ActiveSupport::Cache is used.
       self.cache_formatters = true
 
       # Relationship reflection invokes the related resource when updates
       # are made to a has_many relationship. By default relationship_reflection
       # is turned off because it imposes a small performance penalty.
       self.use_relationship_reflection = false
+
+      # Resource cache
+      # An ActiveSupport::Cache::Store or similar, used by Resources with caching enabled.
+      # Set to `nil` (the default) to disable caching, or to `Rails.cache` to use the
+      # Rails cache store.
+      self.resource_cache = nil
+
+      # Default resource cache field
+      # On Resources with caching enabled, this field will be used to check for out-of-date
+      # cache entries, unless overridden on a specific Resource. Defaults to "updated_at".
+      self.default_resource_cache_field = :updated_at
+
+      # Resource cache digest function
+      # Provide a callable that returns a unique value for string inputs with
+      # low chance of collision. The default is SHA256 base64.
+      self.resource_cache_digest_function = Digest::SHA2.new.method(:base64digest)
+
+      # Resource cache usage reporting
+      # Optionally provide a callable which JSONAPI will call with information about cache
+      # performance. Should accept three arguments: resource name, hits count, misses count.
+      self.resource_cache_usage_report_function = nil
     end
 
     def cache_formatters=(bool)
@@ -109,14 +146,14 @@ module JSONAPI
 
     def json_key_format=(format)
       @json_key_format = format
-      if @cache_formatters
+      if defined?(@cache_formatters)
         @key_formatter_tlv = Concurrent::ThreadLocalVar.new
       end
     end
 
     def route_format=(format)
       @route_format = format
-      if @cache_formatters
+      if defined?(@cache_formatters)
         @route_formatter_tlv = Concurrent::ThreadLocalVar.new
       end
     end
@@ -156,7 +193,8 @@ module JSONAPI
     end
 
     def exception_class_whitelisted?(e)
-      @exception_class_whitelist.flatten.any? { |k| e.class.ancestors.include?(k) }
+      @whitelist_all_exceptions ||
+        @exception_class_whitelist.flatten.any? { |k| e.class.ancestors.map(&:to_s).include?(k.to_s) }
     end
 
     def default_processor_klass=(default_processor_klass)
@@ -185,8 +223,12 @@ module JSONAPI
 
     attr_writer :allow_transactions
 
+    attr_writer :include_backtraces_in_errors
+
     attr_writer :exception_class_whitelist
 
+    attr_writer :whitelist_all_exceptions
+
     attr_writer :always_include_to_one_linkage_data
 
     attr_writer :always_include_to_many_linkage_data
@@ -194,6 +236,14 @@ module JSONAPI
     attr_writer :raise_if_parameters_not_allowed
 
     attr_writer :use_relationship_reflection
+
+    attr_writer :resource_cache
+
+    attr_writer :default_resource_cache_field
+
+    attr_writer :resource_cache_digest_function
+
+    attr_writer :resource_cache_usage_report_function
   end
 
   class << self