jsonapi-resources 0.9.0 → 0.9.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a367b0f58fd1570cdc45f28570f440ab2b68c1c7
-  data.tar.gz: 48fdfb4691776dea1491b237c7f9fc1eca401072
+SHA256:
+  metadata.gz: bfb7891ac7686be582e0831afd808f08504e492998968e704de2086c1656e9af
+  data.tar.gz: edeb27a90bec0a6fc79f67e0311cdf7e588fdcf347426489c21d94bcd40a3f28
 SHA512:
-  metadata.gz: a1664c0f610a4baaa22c80642575cdb177910476d0d3154bf259902e24b27261ee26b2f385820a360bb50a229a5e74c04ed55fd69f6507ab3596db6cf5324cc9
-  data.tar.gz: b372447e19a732fadcdb1154894f963460187a2b92e5481df411b798b27347808f4d79f90c51f49b6198a95cd7c1e2d05901ca5a42463064ee89340c80ffa4ad
+  metadata.gz: 645534a3b1811e939fb6e36098e7624072793b59a39eecc99b05743ff77e91289ca6b35441c614220833049b689f8bcf7b6b6fb9fb1f09190b239b706b3d2da7
+  data.tar.gz: 7b562179f5f6ab17179c71208838fccaa1703d6c88eb99356075daa255a57242f59972e5ba0118740d4d80f7bc5706f2f87b4e99b0840cca32d00b19056f5712

data/lib/jsonapi/acts_as_resource_controller.rb

@@ -125,7 +125,8 @@ module JSONAPI
         base_url: base_url,
         key_formatter: key_formatter,
         route_formatter: route_formatter,
-        serialization_options: serialization_options
+        serialization_options: serialization_options,
+        controller: self
       )
       @resource_serializer
     end
@@ -234,7 +235,7 @@ module JSONAPI
       end
 
       render_options[:location] = content[:data]["links"][:self] if (
-        response_doc.status == :created && content[:data].class != Array
+        response_doc.status == :created && content[:data].class != Array && content[:data]["links"]
       )
 
       # For whatever reason, `render` ignores :status and :content_type when :body is set.

data/lib/jsonapi/configuration.rb

@@ -8,6 +8,7 @@ module JSONAPI
                 :resource_key_type,
                 :route_format,
                 :raise_if_parameters_not_allowed,
+                :warn_on_missing_routes,
                 :allow_include,
                 :allow_sort,
                 :allow_filter,
@@ -32,7 +33,8 @@ module JSONAPI
                 :resource_cache,
                 :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
@@ -51,6 +53,8 @@ module JSONAPI
 
       self.raise_if_parameters_not_allowed = true
 
+      self.warn_on_missing_routes = true
+
       # :none, :offset, :paged, or a custom paginator name
       self.default_paginator = :none
 
@@ -131,6 +135,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)
@@ -235,6 +245,8 @@ module JSONAPI
 
     attr_writer :raise_if_parameters_not_allowed
 
+    attr_writer :warn_on_missing_routes
+
     attr_writer :use_relationship_reflection
 
     attr_writer :resource_cache
@@ -244,6 +256,8 @@ module JSONAPI
     attr_writer :resource_cache_digest_function
 
     attr_writer :resource_cache_usage_report_function
+
+    attr_writer :default_exclude_links
   end
 
   class << self

data/lib/jsonapi/exceptions.rb

@@ -364,24 +364,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.parameter_not_allowed.detail',
+                                                    default: "#{param} is not allowed.", param: param))]
       end
     end
 
@@ -451,11 +448,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 +475,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 +485,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 +498,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/include_directives.rb

@@ -40,6 +40,16 @@ module JSONAPI
       delve_paths(get_includes(@include_directives_hash, false))
     end
 
+    def merge_filter(relation, filter)
+      config = include_config(relation.to_sym)
+      config[:include_filters] ||= {}
+      config[:include_filters].merge!(filter)
+    end
+
+    def include_config(relation)
+      @include_directives_hash[:include_related][relation]
+    end
+
     private
 
     def get_related(current_path)
@@ -52,7 +62,7 @@ module JSONAPI
           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}."
+          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

data/lib/jsonapi/link_builder.rb

@@ -3,107 +3,100 @@ module JSONAPI
     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 }#{ serialized_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,12 +105,19 @@ module JSONAPI
     end
 
     def formatted_module_path_from_class(klass)
-      scopes = module_scopes_from_class(klass)
+      @_module_path_cache ||= {}
+      @_module_path_cache[klass] ||= begin
+        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('/') }/"
-      else
-        "/"
+        unless scopes.empty?
+          "/#{ scopes.map {|scope| format_route(scope.to_s.underscore)}.compact.join('/') }/"
+        else
+          "/"
+        end
       end
     end
 
@@ -125,24 +125,25 @@ module JSONAPI
       klass.name.to_s.split("::")[0...-1]
     end
 
-    def regular_resources_path(source_klass)
-      @resources_path_cache.get(source_klass)
+    def resources_path(source_klass)
+      formatted_module_path_from_class(source_klass) + format_route(source_klass._type.to_s)
     end
 
-    def regular_primary_resources_path
-      regular_resources_path(primary_resource_klass)
-    end
+    def resource_path(source)
+      url = "#{resources_path(source.class)}"
 
-    def regular_primary_resources_url
-      "#{ base_url }#{ regular_primary_resources_path }"
+      unless source.class.singleton?
+        url = "#{url}/#{source.id}"
+      end
+      url
     end
 
-    def regular_resource_path(source)
-      "#{regular_resources_path(source.class)}/#{source.id}"
+    def resource_url(source)
+      "#{ base_url }#{ serialized_engine_mount_point }#{ resource_path(source) }"
     end
 
-    def regular_resource_url(source)
-      "#{ base_url }#{ regular_resource_path(source) }"
+    def serialized_engine_mount_point
+      engine_mount_point == "/" ? "" : engine_mount_point
     end
 
     def route_for_relationship(relationship)

data/lib/jsonapi/operation_result.rb

@@ -53,7 +53,7 @@ module JSONAPI
     end
   end
 
-  class LinksObjectOperationResult < OperationResult
+  class RelationshipOperationResult < OperationResult
     attr_accessor :parent_resource, :relationship
 
     def initialize(code, parent_resource, relationship, options = {})

data/lib/jsonapi/processor.rb

@@ -100,7 +100,7 @@ module JSONAPI
       end
 
       if JSONAPI.configuration.top_level_links_include_pagination && paginator
-        page_options[:pagination_params] = paginator.links_page_params(page_options)
+        page_options[:pagination_params] = paginator.links_page_params(page_options.merge(fetched_resources: resource_records))
       end
 
       return JSONAPI::ResourcesOperationResult.new(:ok, resource_records, page_options)
@@ -136,9 +136,9 @@ module JSONAPI
 
       parent_resource = resource_klass.find_by_key(parent_key, context: context)
 
-      return JSONAPI::LinksObjectOperationResult.new(:ok,
-                                                     parent_resource,
-                                                     resource_klass._relationship(relationship_type))
+      return JSONAPI::RelationshipOperationResult.new(:ok,
+                                                      parent_resource,
+                                                      resource_klass._relationship(relationship_type))
     end
 
     def show_related_resource
@@ -166,9 +166,10 @@ module JSONAPI
       include_directives = params[:include_directives]
 
       source_resource ||= source_klass.find_by_key(source_id, context: context, fields: fields)
+      verified_filters = resource_klass.verify_filters(filters, context)
 
       rel_opts = {
-        filters:  filters,
+        filters:  verified_filters,
         sort_criteria: sort_criteria,
         paginator: paginator,
         fields: fields,
@@ -196,7 +197,7 @@ module JSONAPI
           (paginator && paginator.class.requires_record_count) ||
           (JSONAPI.configuration.top_level_meta_include_page_count))
         related_resource_records = source_resource.public_send("records_for_" + relationship_type)
-        records = resource_klass.filter_records(filters, {},
+        records = resource_klass.filter_records(verified_filters, rel_opts,
                                                 related_resource_records)
 
         record_count = resource_klass.count_records(records)
@@ -209,7 +210,7 @@ module JSONAPI
       pagination_params = if paginator && JSONAPI.configuration.top_level_links_include_pagination
                             page_options = {}
                             page_options[:record_count] = record_count if paginator.class.requires_record_count
-                            paginator.links_page_params(page_options)
+                            paginator.links_page_params(page_options.merge(fetched_resources: related_resources))
                           else
                             {}
                           end

data/lib/jsonapi/relationship.rb

@@ -4,6 +4,8 @@ module JSONAPI
                 :class_name, :polymorphic, :always_include_linkage_data,
                 :parent_resource, :eager_load_on_include
 
+    attr_accessor :_routed, :_warned_missing_route
+
     def initialize(name, options = {})
       @name = name.to_s
       @options = options
@@ -14,6 +16,10 @@ module JSONAPI
       @polymorphic = options.fetch(:polymorphic, false) == true
       @always_include_linkage_data = options.fetch(:always_include_linkage_data, false) == true
       @eager_load_on_include = options.fetch(:eager_load_on_include, true) == true
+      @_routed = false
+      @_warned_missing_route = false
+
+      exclude_links(options.fetch(:exclude_links, JSONAPI.configuration.default_exclude_links))
     end
 
     alias_method :polymorphic?, :polymorphic
@@ -49,8 +55,14 @@ module JSONAPI
 
     def type_for_source(source)
       if polymorphic?
-        resource = source.public_send(name)
-        resource.class._type if resource
+        # try polymorphic type column before asking it from the resource record
+        if source._model.respond_to?(polymorphic_type)
+          model_type = source._model.send(polymorphic_type)
+          source.class.resource_for(model_type)._type if model_type
+        else
+          resource = source.public_send(name)
+          resource.class._type if resource
+        end
       else
         type
       end
@@ -60,6 +72,27 @@ module JSONAPI
       false
     end
 
+    def exclude_links(exclude)
+      case exclude
+        when :default, "default"
+          @_exclude_links = [:self, :related]
+        when :none, "none"
+          @_exclude_links = []
+        when Array
+          @_exclude_links = exclude.collect {|link| link.to_sym}
+        else
+          fail "Invalid exclude_links"
+      end
+    end
+
+    def _exclude_links
+      @_exclude_links ||= []
+    end
+
+    def exclude_link?(link)
+      _exclude_links.include?(link.to_sym)
+    end
+
     class ToOne < Relationship
       attr_reader :foreign_key_on
 
@@ -70,6 +103,12 @@ module JSONAPI
         @foreign_key_on = options.fetch(:foreign_key_on, :self)
       end
 
+      def to_s
+        # :nocov:
+        "#{parent_resource}.#{name}(#{belongs_to? ? 'BelongsToOne' : 'ToOne'})"
+        # :nocov:
+      end
+
       def belongs_to?
         foreign_key_on == :self
       end
@@ -89,6 +128,12 @@ module JSONAPI
         @reflect = options.fetch(:reflect, true) == true
         @inverse_relationship = options.fetch(:inverse_relationship, parent_resource._type.to_s.singularize.to_sym) if parent_resource
       end
+
+      def to_s
+        # :nocov:
+        "#{parent_resource}.#{name}(ToMany)"
+        # :nocov:
+      end
     end
   end
 end

data/lib/jsonapi/relationship_builder.rb

@@ -60,16 +60,16 @@ module JSONAPI
 
         resource_klass = relationship.resource_klass
 
+        records = resource_klass.apply_includes(records, options)
+
         filters = options.fetch(:filters, {})
         unless filters.nil? || filters.empty?
           records = resource_klass.apply_filters(records, filters, options)
         end
 
         sort_criteria =  options.fetch(:sort_criteria, {})
-        unless sort_criteria.nil? || sort_criteria.empty?
-          order_options = relationship.resource_klass.construct_order_options(sort_criteria)
-          records = resource_klass.apply_sort(records, order_options, @context)
-        end
+        order_options = relationship.resource_klass.construct_order_options(sort_criteria)
+        records = resource_klass.apply_sort(records, order_options, @context)
 
         paginator = options[:paginator]
         if paginator