jsonapi-resources 0.9.0 → 0.10.6

data/lib/jsonapi/cached_response_fragment.rb

@@ -0,0 +1,127 @@
+module JSONAPI
+  class CachedResponseFragment
+
+    Lookup = Struct.new(:resource_klass, :serializer_config_key, :context, :context_key, :cache_ids) do
+
+      def type
+        resource_klass._type
+      end
+
+      def keys
+        cache_ids.map do |(id, cache_key)|
+          [type, id, cache_key, serializer_config_key, context_key]
+        end
+      end
+    end
+
+    Write = Struct.new(:resource_klass, :resource, :serializer, :serializer_config_key, :context, :context_key, :relationship_data) do
+      def to_key_value
+
+        (id, cache_key) = resource.cache_id
+
+        json = serializer.object_hash(resource, relationship_data)
+
+        cr = CachedResponseFragment.new(
+          resource_klass,
+          id,
+          json['type'],
+          context,
+          resource.fetchable_fields,
+          json['relationships'],
+          json['links'],
+          json['attributes'],
+          json['meta']
+        )
+
+        key = [resource_klass._type, id, cache_key, serializer_config_key, context_key]
+
+        [key, cr]
+      end
+    end
+
+    attr_reader :resource_klass, :id, :type, :context, :fetchable_fields, :relationships,
+                :links_json, :attributes_json, :meta_json
+
+    def initialize(resource_klass, id, type, context, fetchable_fields, relationships,
+                   links_json, attributes_json, meta_json)
+      @resource_klass = resource_klass
+      @id = id
+      @type = type
+      @context = context
+      @fetchable_fields = Set.new(fetchable_fields)
+
+      # Relationships left uncompiled because we'll often want to insert included ids on retrieval
+      # Remove the data since that should not be cached
+      @relationships = relationships&.transform_values {|v| v.delete_if {|k, _v| k == 'data'} }
+      @links_json = CompiledJson.of(links_json)
+      @attributes_json = CompiledJson.of(attributes_json)
+      @meta_json = CompiledJson.of(meta_json)
+    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
+
+    # @param [Lookup[]] lookups
+    # @return [Hash<Class<Resource>, Hash<ID, CachedResourceFragment>>]
+    def self.lookup(lookups, context)
+      type_to_klass = lookups.map {|l| [l.type, l.resource_klass]}.to_h
+
+      keys = lookups.map(&:keys).flatten(1)
+
+      hits = JSONAPI.configuration.resource_cache.read_multi(*keys).reject {|_, v| v.nil?}
+
+      return keys.inject({}) do |hash, key|
+        (type, id, _, _) = key
+        resource_klass = type_to_klass[type]
+        hash[resource_klass] ||= {}
+
+        if hits.has_key?(key)
+          hash[resource_klass][id] = self.from_cache_value(resource_klass, context, hits[key])
+        else
+          hash[resource_klass][id] = nil
+        end
+
+        hash
+      end
+    end
+
+    # @param [Write[]] lookups
+    def self.write(writes)
+      key_values = writes.map(&:to_key_value)
+
+      to_write = key_values.map {|(k, v)| [k, v.to_cache_value]}.to_h
+
+      if JSONAPI.configuration.resource_cache.respond_to? :write_multi
+        JSONAPI.configuration.resource_cache.write_multi(to_write)
+      else
+        to_write.each do |key, value|
+          JSONAPI.configuration.resource_cache.write(key, value)
+        end
+      end
+
+    end
+
+    def self.from_cache_value(resource_klass, context, h)
+      new(
+        resource_klass,
+        h.fetch(:id),
+        h.fetch(:type),
+        context,
+        h.fetch(:fetchable),
+        h.fetch(:rels, nil),
+        h.fetch(:links, nil),
+        h.fetch(:attrs, nil),
+        h.fetch(:meta, nil)
+      )
+    end
+  end
+end

data/lib/jsonapi/compiled_json.rb

@@ -5,6 +5,7 @@ module JSONAPI
     end
 
     def self.of(obj)
+      # :nocov:
       case obj
         when NilClass then nil
         when CompiledJson then obj
@@ -12,6 +13,7 @@ module JSONAPI
         when Hash then CompiledJson.compile(obj)
         else raise "Can't figure out how to turn #{obj.inspect} into CompiledJson"
       end
+      # :nocov:
     end
 
     def initialize(json, h = nil)
@@ -19,7 +21,7 @@ module JSONAPI
       @h = h
     end
 
-    def to_json(*args)
+    def to_json(*_args)
       @json
     end
 
@@ -27,9 +29,17 @@ module JSONAPI
       @json
     end
 
+    # :nocov:
     def to_h
       @h ||= JSON.parse(@json)
     end
+    # :nocov:
+
+    def [](key)
+      # :nocov:
+      to_h[key]
+      # :nocov:
+    end
 
     undef_method :as_json
   end

data/lib/jsonapi/configuration.rb

@@ -8,13 +8,17 @@ module JSONAPI
                 :resource_key_type,
                 :route_format,
                 :raise_if_parameters_not_allowed,
-                :allow_include,
+                :warn_on_route_setup_issues,
+                :warn_on_missing_routes,
+                :warn_on_performance_issues,
+                :default_allow_include_to_one,
+                :default_allow_include_to_many,
                 :allow_sort,
                 :allow_filter,
                 :default_paginator,
                 :default_page_size,
                 :maximum_page_size,
-                :default_processor_klass,
+                :default_processor_klass_name,
                 :use_text_errors,
                 :top_level_links_include_pagination,
                 :top_level_meta_include_record_count,
@@ -23,6 +27,7 @@ module JSONAPI
                 :top_level_meta_page_count_key,
                 :allow_transactions,
                 :include_backtraces_in_errors,
+                :include_application_backtraces_in_errors,
                 :exception_class_whitelist,
                 :whitelist_all_exceptions,
                 :always_include_to_one_linkage_data,
@@ -30,9 +35,12 @@ module JSONAPI
                 :cache_formatters,
                 :use_relationship_reflection,
                 :resource_cache,
+                :default_caching,
                 :default_resource_cache_field,
                 :resource_cache_digest_function,
-                :resource_cache_usage_report_function
+                :resource_cache_usage_report_function,
+                :default_exclude_links,
+                :use_related_resource_records_for_joins
 
     def initialize
       #:underscored_key, :camelized_key, :dasherized_key, or custom
@@ -45,12 +53,17 @@ module JSONAPI
       self.resource_key_type = :integer
 
       # optional request features
-      self.allow_include = true
+      self.default_allow_include_to_one = true
+      self.default_allow_include_to_many = true
       self.allow_sort = true
       self.allow_filter = true
 
       self.raise_if_parameters_not_allowed = true
 
+      self.warn_on_route_setup_issues = true
+      self.warn_on_missing_routes = true
+      self.warn_on_performance_issues = true
+
       # :none, :offset, :paged, or a custom paginator name
       self.default_paginator = :none
 
@@ -71,8 +84,12 @@ 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?
+      # responses.  Defaults to `false` in anything other than development or test.
+      self.include_backtraces_in_errors = (Rails.env.development? || Rails.env.test?)
+
+      # Whether or not to include exception application backtraces in JSONAPI error
+      # responses.  Defaults to `false` in anything other than development or test.
+      self.include_application_backtraces_in_errors = (Rails.env.development? || Rails.env.test?)
 
       # List of classes that should not be rescued by the operations processor.
       # For example, if you use Pundit for authorization, you might
@@ -94,7 +111,7 @@ module JSONAPI
 
       # The default Operation Processor to use if one is not defined specifically
       # for a Resource.
-      self.default_processor_klass = JSONAPI::Processor
+      self.default_processor_klass_name = 'JSONAPI::Processor'
 
       # Allows transactions for creating and updating records
       # Set this to false if your backend does not support transactions (e.g. Mongodb)
@@ -117,6 +134,11 @@ module JSONAPI
       # Rails cache store.
       self.resource_cache = nil
 
+      # Cache resources by default
+      # Cache resources by default. Individual resources can be excluded from caching by calling:
+      # `caching false`
+      self.default_caching = false
+
       # 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".
@@ -131,6 +153,17 @@ module JSONAPI
       # 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
+
+      # Global configuration for links exclusion
+      # Controls whether to generate links like `self`, `related` with all the resources
+      # and relationships. Accepts either `:default`, `:none`, or array containing the
+      # specific default links to exclude, which may be `:self` and `:related`.
+      self.default_exclude_links = :none
+
+      # Use a related resource's `records` when performing joins. This setting allows included resources to account for
+      # permission scopes. It can be overridden explicitly per relationship. Furthermore, specifying a `relation_name`
+      # on a relationship will cause this setting to be ignored.
+      self.use_related_resource_records_for_joins = true
     end
 
     def cache_formatters=(bool)
@@ -198,10 +231,26 @@ module JSONAPI
     end
 
     def default_processor_klass=(default_processor_klass)
+      ActiveSupport::Deprecation.warn('`default_processor_klass` has been replaced by `default_processor_klass_name`.')
       @default_processor_klass = default_processor_klass
     end
 
-    attr_writer :allow_include, :allow_sort, :allow_filter
+    def default_processor_klass
+      @default_processor_klass ||= default_processor_klass_name.safe_constantize
+    end
+
+    def default_processor_klass_name=(default_processor_klass_name)
+      @default_processor_klass = nil
+      @default_processor_klass_name = default_processor_klass_name
+    end
+
+    def allow_include=(allow_include)
+      ActiveSupport::Deprecation.warn('`allow_include` has been replaced by `default_allow_include_to_one` and `default_allow_include_to_many` options.')
+      @default_allow_include_to_one = allow_include
+      @default_allow_include_to_many = allow_include
+    end
+
+    attr_writer :allow_sort, :allow_filter, :default_allow_include_to_one, :default_allow_include_to_many
 
     attr_writer :default_paginator
 
@@ -225,6 +274,8 @@ module JSONAPI
 
     attr_writer :include_backtraces_in_errors
 
+    attr_writer :include_application_backtraces_in_errors
+
     attr_writer :exception_class_whitelist
 
     attr_writer :whitelist_all_exceptions
@@ -235,15 +286,27 @@ module JSONAPI
 
     attr_writer :raise_if_parameters_not_allowed
 
+    attr_writer :warn_on_route_setup_issues
+
+    attr_writer :warn_on_missing_routes
+
+    attr_writer :warn_on_performance_issues
+
     attr_writer :use_relationship_reflection
 
     attr_writer :resource_cache
 
+    attr_writer :default_caching
+
     attr_writer :default_resource_cache_field
 
     attr_writer :resource_cache_digest_function
 
     attr_writer :resource_cache_usage_report_function
+
+    attr_writer :default_exclude_links
+
+    attr_writer :use_related_resource_records_for_joins
   end
 
   class << self

data/lib/jsonapi/error.rb

@@ -24,6 +24,33 @@ module JSONAPI
       instance_variables.each {|var| hash[var.to_s.delete('@')] = instance_variable_get(var) unless instance_variable_get(var).nil? }
       hash
     end
+
+    def update_with_overrides(error_object_overrides)
+      @title          = error_object_overrides[:title] || @title
+      @detail         = error_object_overrides[:detail] || @detail
+      @id             = error_object_overrides[:id] || @id
+      @href           = error_object_overrides[:href] || href
+
+      if error_object_overrides[:code]
+        # :nocov:
+        @code           = if JSONAPI.configuration.use_text_errors
+                            TEXT_ERRORS[error_object_overrides[:code]]
+                          else
+                            error_object_overrides[:code]
+                          end
+        # :nocov:
+      end
+
+      @source         = error_object_overrides[:source] || @source
+      @links          = error_object_overrides[:links] || @links
+
+      if error_object_overrides[:status]
+        # :nocov:
+        @status         = Rack::Utils::SYMBOL_TO_STATUS_CODE[error_object_overrides[:status]].to_s
+        # :nocov:
+      end
+      @meta           = error_object_overrides[:meta] || @meta
+    end
   end
 
   class Warning

data/lib/jsonapi/error_codes.rb

@@ -20,6 +20,7 @@ module JSONAPI
   INVALID_FILTERS_SYNTAX = '120'
   SAVE_FAILED = '121'
   INVALID_DATA_FORMAT = '122'
+  INVALID_RELATIONSHIP = '123'
   BAD_REQUEST = '400'
   FORBIDDEN = '403'
   RECORD_NOT_FOUND = '404'
@@ -50,6 +51,7 @@ module JSONAPI
       INVALID_FILTERS_SYNTAX => 'INVALID_FILTERS_SYNTAX',
       SAVE_FAILED => 'SAVE_FAILED',
       INVALID_DATA_FORMAT => 'INVALID_DATA_FORMAT',
+      INVALID_RELATIONSHIP => 'INVALID_RELATIONSHIP',
       FORBIDDEN => 'FORBIDDEN',
       RECORD_NOT_FOUND => 'RECORD_NOT_FOUND',
       NOT_ACCEPTABLE => 'NOT_ACCEPTABLE',

data/lib/jsonapi/exceptions.rb

@@ -1,7 +1,7 @@
 module JSONAPI
   module Exceptions
     class Error < RuntimeError
-      attr :error_object_overrides
+      attr_reader :error_object_overrides
 
       def initialize(error_object_overrides = {})
         @error_object_overrides = error_object_overrides
@@ -18,6 +18,22 @@ module JSONAPI
       end
     end
 
+    class Errors < Error
+      def initialize(errors, error_object_overrides = {})
+        @errors = errors
+
+        @errors.each do |error|
+          error.update_with_overrides(error_object_overrides)
+        end
+
+        super(error_object_overrides)
+      end
+
+      def errors
+        @errors
+      end
+    end
+
     class InternalServerError < Error
       attr_accessor :exception
 
@@ -33,6 +49,12 @@ module JSONAPI
           meta[:backtrace] = exception.backtrace
         end
 
+        if JSONAPI.configuration.include_application_backtraces_in_errors
+          meta ||= Hash.new
+          meta[:exception] ||= exception.message
+          meta[:application_backtrace] = exception.backtrace.select{|line| line =~ /#{Rails.root}/}
+        end
+
         [create_error_object(code: JSONAPI::INTERNAL_SERVER_ERROR,
                              status: :internal_server_error,
                              title: I18n.t('jsonapi-resources.exceptions.internal_server_error.title',
@@ -119,49 +141,30 @@ module JSONAPI
       end
     end
 
-
-    class HasManyRelationExists < Error
-      attr_accessor :id
-
-      def initialize(id, error_object_overrides = {})
-        @id = id
-        super(error_object_overrides)
-      end
-
-      def errors
-        [create_error_object(code: JSONAPI::RELATION_EXISTS,
-                             status: :bad_request,
-                             title: I18n.translate('jsonapi-resources.exceptions.has_many_relation.title',
-                                                   default: 'Relation exists'),
-                             detail: I18n.translate('jsonapi-resources.exceptions.has_many_relation.detail',
-                                                    default: "The relation to #{id} already exists.",
-                                                    id: id))]
-      end
-    end
-
     class BadRequest < Error
-      def initialize(exception)
+      def initialize(exception, error_object_overrides = {})
         @exception = exception
+        super(error_object_overrides)
       end
 
       def errors
-        [JSONAPI::Error.new(code: JSONAPI::BAD_REQUEST,
-                            status: :bad_request,
-                            title: I18n.translate('jsonapi-resources.exceptions.bad_request.title',
-                                                  default: 'Bad Request'),
-                            detail: I18n.translate('jsonapi-resources.exceptions.bad_request.detail',
-                                                   default: @exception))]
+        [create_error_object(code: JSONAPI::BAD_REQUEST,
+                             status: :bad_request,
+                             title: I18n.translate('jsonapi-resources.exceptions.bad_request.title',
+                                                   default: 'Bad Request'),
+                             detail: I18n.translate('jsonapi-resources.exceptions.bad_request.detail',
+                                                    default: @exception))]
       end
     end
 
     class InvalidRequestFormat < Error
       def errors
-        [JSONAPI::Error.new(code: JSONAPI::BAD_REQUEST,
-                            status: :bad_request,
-                            title: I18n.translate('jsonapi-resources.exceptions.invalid_request_format.title',
-                                                  default: 'Bad Request'),
-                            detail: I18n.translate('jsonapi-resources.exceptions.invalid_request_format.detail',
-                                                   default: 'Request must be a hash'))]
+        [create_error_object(code: JSONAPI::BAD_REQUEST,
+                             status: :bad_request,
+                             title: I18n.translate('jsonapi-resources.exceptions.invalid_request_format.title',
+                                                   default: 'Bad Request'),
+                             detail: I18n.translate('jsonapi-resources.exceptions.invalid_request_format.detail',
+                                                    default: 'Request must be a hash'))]
       end
     end
 
@@ -324,6 +327,26 @@ module JSONAPI
       end
     end
 
+    class InvalidRelationship < Error
+      attr_accessor :relationship_name, :type
+
+      def initialize(type, relationship_name, error_object_overrides = {})
+        @relationship_name = relationship_name
+        @type = type
+        super(error_object_overrides)
+      end
+
+      def errors
+        [create_error_object(code: JSONAPI::INVALID_RELATIONSHIP,
+                             status: :bad_request,
+                             title: I18n.translate('jsonapi-resources.exceptions.invalid_relationship.title',
+                                                   default: 'Invalid relationship'),
+                             detail: I18n.translate('jsonapi-resources.exceptions.invalid_relationship.detail',
+                                                    default: "#{relationship_name} is not a valid field for #{type}.",
+                                                    relationship_name: relationship_name, type: type))]
+      end
+    end
+
     class InvalidInclude < Error
       attr_accessor :relationship, :resource
 
@@ -339,7 +362,7 @@ module JSONAPI
                              title: I18n.translate('jsonapi-resources.exceptions.invalid_include.title',
                                                    default: 'Invalid field'),
                              detail: I18n.translate('jsonapi-resources.exceptions.invalid_include.detail',
-                                                    default: "#{relationship} is not a valid relationship of #{resource}",
+                                                    default: "#{relationship} is not a valid includable relationship of #{resource}",
                                                     relationship: relationship, resource: resource))]
       end
     end
@@ -364,24 +387,21 @@ module JSONAPI
       end
     end
 
-    class ParametersNotAllowed < Error
-      attr_accessor :params
+    class ParameterNotAllowed < Error
+      attr_accessor :param
 
-      def initialize(params, error_object_overrides = {})
-        @params = params
+      def initialize(param, error_object_overrides = {})
+        @param = param
         super(error_object_overrides)
       end
 
       def errors
-        params.collect do |param|
-          create_error_object(code: JSONAPI::PARAM_NOT_ALLOWED,
-                              status: :bad_request,
-                              title: I18n.translate('jsonapi-resources.exceptions.parameters_not_allowed.title',
-                                                    default: 'Param not allowed'),
-                              detail: I18n.translate('jsonapi-resources.exceptions.parameters_not_allowed.detail',
-                                                     default: "#{param} is not allowed.", param: param))
-
-        end
+        [create_error_object(code: JSONAPI::PARAM_NOT_ALLOWED,
+                            status: :bad_request,
+                            title: I18n.translate('jsonapi-resources.exceptions.parameter_not_allowed.title',
+                                                  default: 'Param not allowed'),
+                            detail: I18n.translate('jsonapi-resources.exceptions.parameters_not_allowed.detail',
+                                                   default: "#{param} is not allowed.", param: param))]
       end
     end
 
@@ -451,11 +471,12 @@ module JSONAPI
     end
 
     class ValidationErrors < Error
-      attr_reader :error_messages, :error_metadata, :resource_relationships
+      attr_reader :error_messages, :error_metadata, :resource_relationships, :resource_class
 
       def initialize(resource, error_object_overrides = {})
         @error_messages = resource.model_error_messages
         @error_metadata = resource.validation_error_metadata
+        @resource_class = resource.class
         @resource_relationships = resource.class._relationships.keys
         @key_formatter = JSONAPI.configuration.key_formatter
         super(error_object_overrides)
@@ -477,7 +498,7 @@ module JSONAPI
         create_error_object(code: JSONAPI::VALIDATION_ERROR,
                             status: :unprocessable_entity,
                             title: message,
-                            detail: "#{format_key(attr_key)} - #{message}",
+                            detail: detail(attr_key, message),
                             source: { pointer: pointer(attr_key) },
                             meta: metadata_for(attr_key, message))
       end
@@ -487,7 +508,12 @@ module JSONAPI
         error_metadata[attr_key] ? error_metadata[attr_key][message] : nil
       end
 
+      def detail(attr_key, message)
+        general_error?(attr_key) ? message : "#{format_key(attr_key)} - #{message}"
+      end
+
       def pointer(attr_or_relationship_name)
+        return '/data' if general_error?(attr_or_relationship_name)
         formatted_attr_or_relationship_name = format_key(attr_or_relationship_name)
         if resource_relationships.include?(attr_or_relationship_name)
           "/data/relationships/#{formatted_attr_or_relationship_name}"
@@ -495,6 +521,10 @@ module JSONAPI
           "/data/attributes/#{formatted_attr_or_relationship_name}"
         end
       end
+
+      def general_error?(attr_key)
+        attr_key.to_sym == :base && !resource_class._has_attribute?(attr_key)
+      end
     end
 
     class SaveFailed < Error

data/lib/jsonapi/formatter.rb

@@ -108,7 +108,7 @@ end
 
 class DasherizedKeyFormatter < JSONAPI::KeyFormatter
   class << self
-    def format(key)
+    def format(_key)
       super.underscore.dasherize
     end
 
@@ -146,7 +146,7 @@ end
 
 class CamelizedRouteFormatter < JSONAPI::RouteFormatter
   class << self
-    def format(route)
+    def format(_route)
       super.camelize(:lower)
     end
 
@@ -158,7 +158,7 @@ end
 
 class DasherizedRouteFormatter < JSONAPI::RouteFormatter
   class << self
-    def format(route)
+    def format(_route)
       super.dasherize
     end