sanger-jsonapi-resources 0.1.1 → 0.2.0

data/lib/jsonapi/cached_response_fragment.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+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/callbacks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/callbacks'
 
 module JSONAPI

data/lib/jsonapi/compatibility_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# JSONAPI::CompatibilityHelper
+#
+# This module provides a version-safe method for issuing deprecation warnings
+# that works across multiple versions of Rails (7.x, 8.x, etc).
+#
+# Usage:
+#   JSONAPI::CompatibilityHelper.deprecation_warn("Your deprecation message")
+#
+# The method will use the public `warn` method if available, otherwise it will
+# use `send(:warn, ...)` to maintain compatibility with Rails 8+ where `warn`
+# is private.
+#
+# Example:
+#   JSONAPI::CompatibilityHelper.deprecation_warn("This feature is deprecated.")
+
+module JSONAPI
+  module CompatibilityHelper
+    def deprecation_warn(message)
+      if ActiveSupport::Deprecation.respond_to?(:warn) && ActiveSupport::Deprecation.public_method_defined?(:warn)
+        ActiveSupport::Deprecation.warn(message)
+      else
+        ActiveSupport::Deprecation.send(:warn, message)
+      end
+    end
+    module_function :deprecation_warn
+  end
+end

data/lib/jsonapi/compiled_json.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class CompiledJson
     def self.compile(h)
@@ -5,6 +7,7 @@ module JSONAPI
     end
 
     def self.of(obj)
+      # :nocov:
       case obj
         when NilClass then nil
         when CompiledJson then obj
@@ -12,6 +15,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 +23,7 @@ module JSONAPI
       @h = h
     end
 
-    def to_json(*args)
+    def to_json(*_args)
       @json
     end
 
@@ -27,9 +31,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

@@ -1,20 +1,26 @@
+# frozen_string_literal: true
+
 require 'jsonapi/formatter'
 require 'jsonapi/processor'
 require 'concurrent'
-
+require_relative 'compatibility_helper'
 module JSONAPI
   class Configuration
     attr_reader :json_key_format,
                 :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,16 +29,19 @@ module JSONAPI
                 :top_level_meta_page_count_key,
                 :allow_transactions,
                 :include_backtraces_in_errors,
-                :exception_class_whitelist,
-                :whitelist_all_exceptions,
+                :include_application_backtraces_in_errors,
+                :exception_class_allowlist,
+                :allow_all_exceptions,
                 :always_include_to_one_linkage_data,
                 :always_include_to_many_linkage_data,
                 :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 +54,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,20 +85,24 @@ 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
       # raise a Pundit::NotAuthorizedError at some point during operations
       # processing. If you want to use Rails' `rescue_from` macro to
       # catch this error and render a 403 status code, you should add
-      # the `Pundit::NotAuthorizedError` to the `exception_class_whitelist`.
-      self.exception_class_whitelist = []
+      # the `Pundit::NotAuthorizedError` to the `exception_class_allowlist`.
+      self.exception_class_allowlist = []
 
-      # If enabled, will override configuration option `exception_class_whitelist`
-      # and whitelist all exceptions.
-      self.whitelist_all_exceptions = false
+      # If enabled, will override configuration option `exception_class_allowlist`
+      # and allow all exceptions.
+      self.allow_all_exceptions = false
 
       # Resource Linkage
       # Controls the serialization of resource linkage for non compound documents
@@ -94,7 +112,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 +135,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 +154,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)
@@ -192,16 +221,42 @@ module JSONAPI
       return formatter
     end
 
-    def exception_class_whitelisted?(e)
-      @whitelist_all_exceptions ||
-        @exception_class_whitelist.flatten.any? { |k| e.class.ancestors.map(&:to_s).include?(k.to_s) }
+    def exception_class_allowed?(e)
+      @allow_all_exceptions ||
+        @exception_class_allowlist.flatten.any? { |k| e.class.ancestors.map(&:to_s).include?(k.to_s) }
     end
 
     def default_processor_klass=(default_processor_klass)
+      JSONAPI::CompatibilityHelper.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)
+      JSONAPI::CompatibilityHelper.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
+
+    def whitelist_all_exceptions=(allow_all_exceptions)
+      JSONAPI::CompatibilityHelper.deprecation_warn('`whitelist_all_exceptions` has been replaced by `allow_all_exceptions`')
+      @allow_all_exceptions = allow_all_exceptions
+    end
+
+    def exception_class_whitelist=(exception_class_allowlist)
+      JSONAPI::CompatibilityHelper.deprecation_warn('`exception_class_whitelist` has been replaced by `exception_class_allowlist`')
+      @exception_class_allowlist = exception_class_allowlist
+    end
+
+    attr_writer :allow_sort, :allow_filter, :default_allow_include_to_one, :default_allow_include_to_many
 
     attr_writer :default_paginator
 
@@ -225,9 +280,11 @@ module JSONAPI
 
     attr_writer :include_backtraces_in_errors
 
-    attr_writer :exception_class_whitelist
+    attr_writer :include_application_backtraces_in_errors
+
+    attr_writer :exception_class_allowlist
 
-    attr_writer :whitelist_all_exceptions
+    attr_writer :allow_all_exceptions
 
     attr_writer :always_include_to_one_linkage_data
 
@@ -235,15 +292,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class Error
     attr_accessor :title, :detail, :id, :href, :code, :source, :links, :status, :meta
@@ -24,6 +26,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   VALIDATION_ERROR = '100'
   INVALID_RESOURCE = '101'
@@ -20,6 +22,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 +53,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',