sanger-jsonapi-resources 0.1.1 → 0.2.0

data/lib/jsonapi/exceptions.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 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 +20,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 +51,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 +143,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 +329,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 +364,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 +389,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 +473,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 +500,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 +510,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 +523,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class Formatter
     class << self
@@ -108,7 +110,7 @@ end
 
 class DasherizedKeyFormatter < JSONAPI::KeyFormatter
   class << self
-    def format(key)
+    def format(_key)
       super.underscore.dasherize
     end
 
@@ -146,7 +148,7 @@ end
 
 class CamelizedRouteFormatter < JSONAPI::RouteFormatter
   class << self
-    def format(route)
+    def format(_route)
       super.camelize(:lower)
     end
 
@@ -158,7 +160,7 @@ end
 
 class DasherizedRouteFormatter < JSONAPI::RouteFormatter
   class << self
-    def format(route)
+    def format(_route)
       super.dasherize
     end
 

data/lib/jsonapi/include_directives.rb

@@ -1,17 +1,17 @@
+# frozen_string_literal: true
+
 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:{
+    #   posts: {
+    #     include_related: {
     #       comments:{
-    #         include:true,
-    #         include_related:{
-    #           tags:{
-    #             include:true
+    #         include_related: {
+    #           tags: {
+    #             include_related: {}
     #           }
     #         }
     #       }
@@ -19,82 +19,37 @@ 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)
       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))
+    def [](name)
+      @include_directives_hash[name]
     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
+    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

data/lib/jsonapi/link_builder.rb

@@ -1,109 +1,104 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class LinkBuilder
     attr_reader :base_url,
                 :primary_resource_klass,
                 :route_formatter,
-                :engine_name
+                :engine,
+                :engine_mount_point,
+                :url_helpers
+
+    @@url_helper_methods = {}
 
     def initialize(config = {})
-      @base_url               = config[:base_url]
+      @base_url = config[:base_url]
       @primary_resource_klass = config[:primary_resource_klass]
-      @route_formatter        = config[:route_formatter]
-      @engine_name            = build_engine_name
+      @route_formatter = config[:route_formatter]
+      @engine = build_engine
+      @engine_mount_point = @engine ? @engine.routes.find_script_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
+      # url_helpers may be either a controller which has the route helper methods, or the application router's
+      # url helpers module, `Rails.application.routes.url_helpers`. Because the method no longer behaves as a
+      # singleton, and it's expensive to generate the module, the controller is preferred.
+      @url_helpers = config[:url_helpers]
     end
 
     def engine?
-      !!@engine_name
+      !!@engine
     end
 
     def primary_resources_url
-      if engine?
-        engine_primary_resources_url
+      if @primary_resource_klass._routed
+        primary_resources_path = resources_path(primary_resource_klass)
+        @primary_resources_url_cached ||= "#{ base_url }#{ engine_mount_point }#{ primary_resources_path }"
       else
-        regular_primary_resources_url
+        if JSONAPI.configuration.warn_on_missing_routes && !@primary_resource_klass._warned_missing_route
+          warn "primary_resources_url for #{@primary_resource_klass} could not be generated"
+          @primary_resource_klass._warned_missing_route = true
+        end
+        nil
       end
     end
 
     def query_link(query_params)
-      "#{ primary_resources_url }?#{ query_params.to_query }"
+      url = primary_resources_url
+      return url if url.nil?
+      "#{ 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
+      if relationship._routed
+        url = "#{ self_link(source) }/#{ route_for_relationship(relationship) }"
+        url = "#{ url }?#{ query_params.to_query }" if query_params.present?
+        url
+      else
+        if JSONAPI.configuration.warn_on_missing_routes && !relationship._warned_missing_route
+          warn "related_link for #{relationship} could not be generated"
+          relationship._warned_missing_route = true
+        end
+        nil
+      end
     end
 
     def relationships_self_link(source, relationship)
-      "#{ self_link(source) }/relationships/#{ route_for_relationship(relationship) }"
+      if relationship._routed
+        "#{ self_link(source) }/relationships/#{ route_for_relationship(relationship) }"
+      else
+        if JSONAPI.configuration.warn_on_missing_routes && !relationship._warned_missing_route
+          warn "self_link for #{relationship} could not be generated"
+          relationship._warned_missing_route = true
+        end
+        nil
+      end
     end
 
     def self_link(source)
-      if engine?
-        engine_resource_url(source)
+      if source.class._routed
+        resource_url(source)
       else
-        regular_resource_url(source)
+        if JSONAPI.configuration.warn_on_missing_routes && !source.class._warned_missing_route
+          warn "self_link for #{source.class} could not be generated"
+          source.class._warned_missing_route = true
+        end
+        nil
       end
     end
 
     private
 
-    def build_engine_name
+    def build_engine
       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"
+          # :nocov:
+      rescue LoadError => _e
+        nil
+        # :nocov:
       end
     end
 
@@ -112,10 +107,14 @@ module JSONAPI
     end
 
     def formatted_module_path_from_class(klass)
-      scopes = module_scopes_from_class(klass)
+      scopes = if @engine
+                 module_scopes_from_class(klass)[1..-1]
+               else
+                 module_scopes_from_class(klass)
+               end
 
       unless scopes.empty?
-        "/#{ scopes.map{ |scope| format_route(scope.to_s.underscore) }.join('/') }/"
+        "/#{ scopes.map {|scope| format_route(scope.to_s.underscore)}.compact.join('/') }/"
       else
         "/"
       end
@@ -125,24 +124,21 @@ module JSONAPI
       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)
+    def resources_path(source_klass)
+      @_resources_path ||= {}
+      @_resources_path[source_klass] ||= formatted_module_path_from_class(source_klass) + format_route(source_klass._type.to_s)
     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}"
+    def resource_path(source)
+      if source.class.singleton?
+        resources_path(source.class)
+      else
+        "#{resources_path(source.class)}/#{source.id}"
+      end
     end
 
-    def regular_resource_url(source)
-      "#{ base_url }#{ regular_resource_path(source) }"
+    def resource_url(source)
+      "#{ base_url }#{ engine_mount_point }#{ resource_path(source) }"
     end
 
     def route_for_relationship(relationship)

data/lib/jsonapi/mime_types.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 
 module JSONAPI
@@ -7,16 +9,10 @@ module JSONAPI
     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:
+      parsers = ActionDispatch::Request.parameter_parsers.merge(
+        Mime::Type.lookup(JSONAPI::MEDIA_TYPE).symbol => parser
+      )
+      ActionDispatch::Request.parameter_parsers = parsers
     end
 
     def self.parser

data/lib/jsonapi/naive_cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
 
   # Cache which memoizes the given block.

data/lib/jsonapi/operation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JSONAPI
   class Operation
     attr_reader :resource_klass, :operation_type, :options
@@ -8,17 +10,28 @@ module JSONAPI
       @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)
+      self.class.processor_instance_for(resource_klass, operation_type, options)
+    end
+
+    class << self
+      def processor_instance_for(resource_klass, operation_type, params)
+        _processor_from_resource_type(resource_klass).new(resource_klass, operation_type, params)
+      end
+
+      def _processor_from_resource_type(resource_klass)
+        processor = resource_klass.name.gsub(/Resource$/,'Processor').safe_constantize
+        if processor.nil?
+          processor = JSONAPI.configuration.default_processor_klass
+        end
+
+        return processor
+      end
     end
   end
 end