jsonapi-resources 0.9.3 → 0.10.5

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
+      @relationships = relationships
+
+      @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,11 @@ 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
 
     def initialize
       #:underscored_key, :camelized_key, :dasherized_key, or custom
@@ -45,12 +52,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 +83,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 +110,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 +133,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 +152,12 @@ 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
     end
 
     def cache_formatters=(bool)
@@ -198,10 +225,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 +268,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 +280,25 @@ 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
   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
@@ -374,11 +397,11 @@ module JSONAPI
 
       def errors
         [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.parameter_not_allowed.detail',
-                                                    default: "#{param} is not allowed.", param: param))]
+                            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
 

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
 

data/lib/jsonapi/include_directives.rb

@@ -4,14 +4,12 @@ module JSONAPI
     # For example ['posts.comments.tags']
     # will transform into =>
     # {
-    #   posts:{
-    #     include:true,
-    #     include_related:{
+    #   posts: {
+    #     include_related: {
     #       comments:{
-    #         include:true,
-    #         include_related:{
-    #           tags:{
-    #             include:true
+    #         include_related: {
+    #           tags: {
+    #             include_related: {}
     #           }
     #         }
     #       }
@@ -19,9 +17,8 @@ module JSONAPI
     #   }
     # }
 
-    def initialize(resource_klass, includes_array, force_eager_load: false)
+    def initialize(resource_klass, includes_array)
       @resource_klass = resource_klass
-      @force_eager_load = force_eager_load
       @include_directives_hash = { include_related: {} }
       includes_array.each do |include|
         parse_include(include)
@@ -32,69 +29,25 @@ module JSONAPI
       @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
-          raise JSONAPI::Exceptions::InvalidInclude.new(current_resource_klass, 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
+    def parse_include(include)
+      path = JSONAPI::Path.new(resource_klass: @resource_klass,
+                               path_string: include,
+                               ensure_default_field: false,
+                               parse_fields: false)
 
-      ir.map do |name, sub_directive|
-        sub = get_includes(sub_directive, only_joined_includes)
-        sub.any? ? { name => sub } : name
-      end
-    end
+      current = @include_directives_hash
 
-    def parse_include(include)
-      parts = include.split('.')
-      local_path = ''
+      path.segments.each do |segment|
+        relationship_name = segment.relationship.name.to_sym
 
-      parts.each do |name|
-        local_path += local_path.length > 0 ? ".#{name}" : name
-        related = get_related(local_path)
-        related[:include] = true
+        current[:include_related][relationship_name] ||= { include_related: {} }
+        current = current[:include_related][relationship_name]
       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
+    rescue JSONAPI::Exceptions::InvalidRelationship => _e
+      raise JSONAPI::Exceptions::InvalidInclude.new(@resource_klass, include)
     end
   end
 end