caprese 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 49d0eb87e9e10a1738d98c359dc8099eac6063bc
-  data.tar.gz: 799eee055e9baefbe79bdd343a1dd1a613de62a0
+  metadata.gz: ca3bb7c32744fab18ebfc77dc7e6cca7df12fd1e
+  data.tar.gz: bbf6d26188979800498a2ae5310a7a56d860b9f5
 SHA512:
-  metadata.gz: 0d547c69920b3a1ab3e2073e7c329627f65a79fbbbba83e1d6a75b715e38ad67f99e5bf7d00c49f793750df1cf58d1cfbeec16e3e5d7ebcc6f740ce441be9abf
-  data.tar.gz: 94cbe72dea9c672aa3730ec6c4533ca7bdaaf395cd56f329c6382578817c4710d452cb38d3be3b0f8726f0f5da961c151f5670c076c80e4d6c0dc8811faa5d60
+  metadata.gz: 74c741443c8b6e7d363bdb2675096b27ec23c7147d39522a9fea8b404d7dc07c48ef0f7ccdcc67eb120b3492a35592a12946879a4e34b4f4351cb02039586c37
+  data.tar.gz: 2166985f7b64d5d99c5f671001430393b533d3d90a14b8231fc67ab1c79f0a233e90a46ab6f084f7c3121866521a38d85bef8b495731c19187c672111312d8e2

data/CHANGELOG.md

@@ -168,4 +168,14 @@
   
 ## 0.4.1
 
-* Allows `:self` link to be overridden in serializers that subclass Caprese::Serializer
+* Allows `:self` link to be overridden in serializers that subclass Caprese::Serializer
+
+## 0.5.0
+
+* Add `relationship_scope(relationship_name, scope) => scope` method for all relationships in serializers, allowing override for custom scoping
+* Refactor `assign_record_attributes` to `assign_changes_from_document`, which splits into multiple modular methods that handle relationship data errors with more source pointer detail
+  * Adds `ResourceDocumentInvalidError` for errors pertaining to the document instead of record assignment (`RecordInvalidError`)
+  * Allows `PATCH` requests to primary endpoints that update autosaving collection relationships  to propagate the nested errors on attributes/relationships up to the primary data so error source pointers are just as detailed as they would be under `POST` requests already
+  * Fields are now assigned in a specific order: attributes, singular relationships, collection relationships
+* Fix issue regarding `:base` field titles interpolated into error messages
+* Add more detailed error responses to `update_relationship_definition` endpoints

data/README.md

@@ -3,7 +3,9 @@
 Caprese is a Rails library for creating RESTful APIs in as few words as possible. It handles all CRUD operations on resources and their associations for you, and you can customize how these operations
 are carried out, allowing for infinite possibilities while focusing on work that matters to you, instead of writing repetitive code for each action of each resource in your application.
 
-For now, the only format that is supported by Caprese is the [JSON API schema](http://jsonapi.org/format/). In the future, Caprese will support a more straightforward (but less powerful) JSON format as well, for simpler use cases.
+For now, the only format that is supported by Caprese is the [JSON API schema.](http://jsonapi.org/format/)
+
+[![Coverage Status](https://coveralls.io/repos/github/nicklandgrebe/caprese/badge.svg)](https://coveralls.io/github/nicklandgrebe/caprese)
 
 ## Installation
 

data/lib/caprese/adapter/json_api/error.rb

@@ -18,6 +18,17 @@ module Caprese
           ]
         end
 
+        def self.document_errors(error_serializer, options)
+          error_attributes = error_serializer.as_json
+          [
+            {
+              code: error_attributes[:code],
+              detail: error_attributes[:message],
+              source: error_source(:pointer, nil, error_attributes[:field])
+            }
+          ]
+        end
+
         # Builds a JSON API Errors Object
         # {http://jsonapi.org/format/#errors JSON API Errors}
         #
@@ -89,12 +100,16 @@ module Caprese
         #       parameter: 'pres'
         #     }
         #   end
-        RESERVED_ATTRIBUTES = %w(type)
+        RESERVED_ATTRIBUTES = %w(id type)
         def self.error_source(source_type, record, attribute_name)
           case source_type
           when :pointer
+            if attribute_name == :base
+              {
+                pointer: JsonApi::JsonPointer.new(:base, record, attribute_name)
+              }
             # [type ...] and other primary data variables
-            if RESERVED_ATTRIBUTES.include?(attribute_name.to_s)
+            elsif RESERVED_ATTRIBUTES.include?(attribute_name.to_s)
               {
                 pointer: JsonApi::JsonPointer.new(:primary_data, record, attribute_name)
               }

data/lib/caprese/adapter/json_api/json_pointer.rb

@@ -9,7 +9,8 @@ module Caprese
           relationship_attribute: '/data/relationships/%s'.freeze,
           relationship_base: '/data/relationships/%s/data'.freeze,
           relationship_primary_data: '/data/relationships/%s/data/%s'.freeze,
-          primary_data: '/data/%s'.freeze
+          primary_data: '/data/%s'.freeze,
+          base: '/data'.freeze
         }.freeze
 
         # Iterates over the field of an error and converts it to a pointer in JSON API format
@@ -50,7 +51,7 @@ module Caprese
                 end
             end
           else
-            format(POINTERS[pointer_type], *[value].flatten)
+            format(POINTERS[pointer_type], *Array.wrap(value))
           end
         end
       end

data/lib/caprese/adapter/json_api.rb

@@ -170,6 +170,8 @@ module Caprese
           hash[:errors] =
             if serializer.resource_errors?
               Error.resource_errors(serializer, instance_options)
+            elsif serializer.document_errors?
+              Error.document_errors(serializer, instance_options)
             else
               Error.param_errors(serializer, instance_options)
             end

data/lib/caprese/controller/concerns/aliasing.rb

@@ -5,7 +5,7 @@ module Caprese
   module Aliasing
     extend ActiveSupport::Concern
 
-    # Records all of the field aliases engaged by the API request (called in `assign_record_attributes` using comparison)
+    # Records all of the field aliases engaged by the API request (called in `assign_changes_from_document` using comparison)
     # so that when the response is returned, the appropriate alias is used in reference to fields
     #
     # Success: @todo

data/lib/caprese/controller/concerns/persistence.rb

@@ -12,10 +12,7 @@ module Caprese
       # @note The only instance this may be called, at least in JSON API settings, is a
       #   missing params['data'] param
       rescue_from ActionController::ParameterMissing do |e|
-        rescue_with_handler Error.new(
-          field: e.param,
-          code: :blank
-        )
+        rescue_with_handler RequestDocumentInvalidError.new(field: :base)
       end
 
       rescue_from ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved do |e|
@@ -43,7 +40,7 @@ module Caprese
       fail_on_type_mismatch(data_params[:type])
 
       record = queried_record_scope.build
-      assign_record_attributes(record, permitted_params_for(:create), data_params)
+      assign_changes_from_document(record, data_params, permitted_params_for(:create))
 
       execute_after_initialize_callbacks(record)
 
@@ -74,7 +71,7 @@ module Caprese
     def update
       fail_on_type_mismatch(data_params[:type])
 
-      assign_record_attributes(queried_record, permitted_params_for(:update), data_params)
+      assign_changes_from_document(queried_record, data_params, permitted_params_for(:update))
 
       execute_before_update_callbacks(queried_record)
       execute_before_save_callbacks(queried_record)
@@ -157,7 +154,8 @@ module Caprese
     # @param [Array] params the params to search for the key in
     # @return [Array,Nil] the nested params for a given key
     def nested_params_for(key, params)
-      params.detect { |p| p.is_a?(Hash) }.try(:[], key.to_sym)
+      key = key.to_sym
+      params.detect { |p| p.is_a?(Hash) && p.has_key?(key) }.try(:[], key)
     end
 
     # Flattens an array of the top level keys for a given set of params
@@ -192,7 +190,7 @@ module Caprese
     #   }
     #   create_params => [:price]
     #
-    #   assign_record_attributes(record, create_params, params)
+    #   assign_changes_from_document(record, params, create_params)
     #     => { price: '...', product: Product<@token='asj38k'> }
     #
     # @example
@@ -215,129 +213,180 @@ module Caprese
     #
     #   create_params => [:price, order_items: [:title, :amount, :tax]]
     #
-    #   assign_record_attributes(record, create_params, params) # => {
+    #   assign_changes_from_document(record, params, create_params) # => {
     #     price: '...',
     #     order_items: [OrderItem<@token=nil,@title='An order item',@amount=5.0,@tax=0.0>]
     #   }
     #
     # @param [ActiveRecord::Base] record the record to build attribute into
-    # @param [Array] permitted_params the permitted params for the action
     # @param [Parameters] data the data sent to the server to construct and assign to the record
+    # @param [Array] permitted_params the permitted params for the action
     # @option [String] parent_relationship_name the parent relationship assigning these attributes to the record, used to determine
     #   engaged aliases @see concerns/aliasing
-    def assign_record_attributes(record, permitted_params, data, parent_relationship_name: nil)
+    def assign_changes_from_document(record, data, permitted_params = [], parent_relationship_name: nil)
       # TODO: Make safe by enforcing that only a single alias/unalias can be engaged at once
-      engaged_field_aliases_object = parent_relationship_name ? (engaged_field_aliases[parent_relationship_name] ||= {}) : engaged_field_aliases
+      aliases_document =
+        if parent_relationship_name
+          engaged_field_aliases[parent_relationship_name] ||= {}
+        else
+          engaged_field_aliases
+        end
 
-      attributes = data[:attributes].try(:permit, *permitted_params).try(:inject, {}) do |out, (attribute_name, val)|
+      if data[:attributes]
+        assign_fields_to_record record, extract_attributes_from_document(
+          record,
+          data[:attributes],
+          permitted_params,
+          aliases_document
+        )
+      end
+
+      if data[:relationships]
+        collection_relationships, singular_relationships =
+          flattened_keys_for(permitted_params)
+          .select { |k|
+            begin
+              record.association(actual_field(k, record.class))
+            rescue ActiveRecord::AssociationNotFoundError
+              false
+            end
+          }
+          .partition { |k| record.association(actual_field(k, record.class)).reflection.collection? }
+          .map { |s|
+            s.map { |r| permitted_params.include?(r) ? r : { r => nested_params_for(r, permitted_params) } }
+          }
+
+        assign_fields_to_record record, extract_relationships_from_document(
+          record,
+          data[:relationships],
+          singular_relationships,
+          aliases_document
+        )
+
+        assign_fields_to_record record, extract_relationships_from_document(
+          record,
+          data[:relationships],
+          collection_relationships,
+          aliases_document
+        )
+      end
+    end
+
+    # Assigns fields to the record conditionally based on whether or not assign_attributes is available
+    # @note Allows non-ActiveRecord models to be handled
+    #
+    # @param [ActiveRecord::Base,Struct] record the record to assign fields to
+    # @param [Hash] fields the fields to assign to the record
+    def assign_fields_to_record(record, fields)
+      if record.respond_to?(:assign_attributes)
+        record.assign_attributes(fields)
+      else
+        fields.each { |k, v| record.send("#{k}=", v) }
+      end
+    end
+
+    # Builds an object of attributes to assign to a record, based on a document
+    #
+    # @param [ActiveRecord] record the record corresponding to the data document
+    # @param [Parameters] data the document to extract attributes from
+    # @param [Array<Symbol,Hash>] permitted_params the permitted attributes that can be assigned through this controller
+    # @param [Hash] aliases_document the aliases document reflects usage of aliases in the data document
+    # @return [Hash] the object of attributes to assign to the record
+    def extract_attributes_from_document(record, data, permitted_params, aliases_document)
+      data.permit(*permitted_params).each_with_object({}) do |(attribute_name, val), attributes|
         attribute_name = attribute_name.to_sym
         actual_attribute_name = actual_field(attribute_name, record.class)
 
         if attribute_name != actual_attribute_name
-          engaged_field_aliases_object[attribute_name] = true
+          aliases_document[attribute_name] = true
         end
 
-        out[actual_attribute_name] = val
-        out
-      end || {}
+        attributes[actual_attribute_name] = val
+      end
+    end
 
-      data[:relationships]
-      .try(:slice, *flattened_keys_for(permitted_params))
-      .try(:each) do |relationship_name, relationship_data|
+    # Builds an object of relationships to assign to a record, based on a document
+    #
+    # @param [ActiveRecord] record the record corresponding to the data document
+    # @param [Parameters] data the document to extract relationships from
+    # @param [Array<Symbol,Hash>] permitted_relationships the permitted relationships that can be assigned through this controller
+    # @param [Hash] aliases_document the aliases document reflects usage of aliases in the data document
+    # @return [Hash] the object of relationships to assign to the record
+    def extract_relationships_from_document(record, data, permitted_relationships, aliases_document)
+      data
+      .slice(*flattened_keys_for(permitted_relationships))
+      .each_with_object({}) do |(relationship_name, relationship_data), relationships|
         relationship_name = relationship_name.to_sym
         actual_relationship_name = actual_field(relationship_name, record.class)
 
         if relationship_name != actual_relationship_name
-          engaged_field_aliases_object[relationship_name] = {}
+          aliases_document[relationship_name] = {}
         end
 
-        # TODO: Add checkme for relationship_name to ensure that format is correct (not Array when actually Record, vice versa)
-        #   No relationship exists as well
+        begin
+          raise RequestDocumentInvalidError.new(field: :base) unless relationship_data.has_key?(:data)
 
-        attributes[actual_relationship_name] = records_for_relationship(
-          record,
-          nested_params_for(relationship_name, permitted_params),
-          relationship_name,
-          relationship_data
-        )
-      end
+          relationship_result = records_for_relationship(
+            record,
+            nested_params_for(relationship_name, permitted_relationships),
+            relationship_name,
+            relationship_data[:data]
+          )
 
-      if record.respond_to?(:assign_attributes)
-        record.assign_attributes(attributes)
-      else
-        attributes.each { |k, v| record.send("#{k}=", v) }
+          reflection = record.association(actual_relationship_name).reflection
+          if (reflection.collection? && !relationship_result.is_a?(Array)) ||
+            (!reflection.collection? && relationship_result.is_a?(Array))
+
+            raise RequestDocumentInvalidError.new(field: :base)
+          end
+
+          if record.persisted? && reflection.collection? &&
+            (inverse_reflection = record.class.reflect_on_association(actual_relationship_name).inverse_of)
+
+            relationship_result.each { |r| r.send("#{inverse_reflection.name}=", record) }
+            invalid_results = relationship_result.reject(&:valid?)
+            raise RecordInvalidError.new(invalid_results.first) if invalid_results.any?
+          end
+
+          relationships[actual_relationship_name] = relationship_result
+        rescue Caprese::RecordNotFoundError => e
+          record.errors.add(relationship_name, :not_found, t: e.t.slice(:value))
+        rescue RecordInvalidError => e
+          propagate_errors_to_parent(
+            record,
+            relationship_name,
+            e.record.errors.to_a
+          )
+        rescue RequestDocumentInvalidError => e
+          propagate_errors_to_parent(
+            record,
+            relationship_name,
+            [e]
+          )
+        end
       end
     end
 
     # Gets all the records for a relationship given a relationship data definition
     #
-    # @param [ActiveRecord::Base] owner the owner of the relationship
+    # @param [ActiveRecord] owner the owner of the relationship
     # @param [Array] permitted_params the permitted params for the
     # @param [String] relationship_name the name of the relationship to get records for
     # @param [Hash,Array<Hash>] relationship_data the resource identifier data to use to find/build records
-    # @return [ActiveRecord::Base,Array<ActiveRecord::Base>] the record(s) for the relationship
+    # @return [ActiveRecord,Array<ActiveRecord>] the record(s) for the relationship
     def records_for_relationship(owner, permitted_params, relationship_name, relationship_data)
-      if relationship_data[:data].is_a?(Array)
-        relationship_data[:data].map do |relationship_data_item|
-          ref = record_for_relationship(owner, relationship_name, relationship_data_item)
-
-          if ref && contains_constructable_data?(relationship_data_item)
-            assign_record_attributes(ref, permitted_params, relationship_data_item, parent_relationship_name: relationship_name)
-          end
+      result = Array.wrap(relationship_data).map do |relationship_data_item|
+        ref = record_for_resource_identifier(relationship_data_item)
 
-          ref
-        end
-      elsif relationship_data[:data].present?
-        ref = record_for_relationship(owner, relationship_name, relationship_data[:data])
-
-        if ref && contains_constructable_data?(relationship_data[:data])
-          assign_record_attributes(ref, permitted_params, relationship_data[:data], parent_relationship_name: relationship_name)
+        if ref && contains_constructable_data?(relationship_data_item)
+          assign_changes_from_document(ref, relationship_data_item, permitted_params, parent_relationship_name: relationship_name)
+          propagate_errors_to_parent(owner, relationship_name, ref.errors.to_a) if ref.errors.any?
         end
 
         ref
-      elsif !relationship_data.has_key?(:data)
-        raise Error.new(
-          field: "/data/relationships/#{relationship_name}/data",
-          code: :blank
-        )
       end
-    end
-
-    # Given a resource identifier, finds or builds a resource for a relationship
-    #
-    # @param [ActiveRecord::Base] owner the owner of the relationship record
-    # @param [String] relationship_name the name of the relationship
-    # @param [Hash] resource_identifier the resource identifier for the resource
-    # @return [ActiveRecord::Base] the found or built resource for the relationship
-    def record_for_relationship(owner, relationship_name, resource_identifier)
-      if resource_identifier[:type]
-        # { type: '...', id: '...' }
-        if (id = resource_identifier[:id])
-          begin
-            get_record!(
-              resource_identifier[:type],
-              Caprese.config.resource_primary_key,
-              id
-            )
-          rescue Caprese::RecordNotFoundError => e
-            owner.errors.add(relationship_name, :not_found, t: { value: id })
-            nil
-          end
 
-        # { type: '...', attributes: { ... } }
-        elsif contains_constructable_data?(resource_identifier)
-          record_scope(resource_identifier[:type].to_sym).build
-
-        # { type: '...' }
-        else
-          owner.errors.add(relationship_name)
-          nil
-        end
-      else
-        # { id: '...' } && { attributes: { ... } }
-        owner.errors.add("#{relationship_name}.type")
-        nil
-      end
+      relationship_data.is_a?(Array) && result || result.first
     end
 
     # Indicates whether or not :attributes or :relationships keys are in a resource identifier,
@@ -349,6 +398,21 @@ module Caprese
       [:attributes, :relationships].any? { |k| resource_identifier.key?(k) }
     end
 
+    # Propagates errors to parent with nested field name
+    #
+    # @param [ActiveRecord] parent the parent to propagate errors to
+    # @param [String] relationship_name the name to use when nesting the errors
+    # @param [Array<Error>] errors the errors to propagate
+    def propagate_errors_to_parent(parent, relationship_name, errors)
+      errors.each do |error|
+        parent.errors.add(
+          error.field == :base ? relationship_name : "#{relationship_name}.#{error.field}",
+          error.code,
+          t: error.t.except(:field, :field_title)
+        )
+      end
+    end
+
     # Called in create, after the record is saved. When creating a new record, and assigning to it
     # existing has_many association relation, the records in the relation will be pushed onto the
     # appropriate target, but the relationship will not be persisted in their attributes until their

data/lib/caprese/controller/concerns/query.rb

@@ -87,6 +87,38 @@ module Caprese
       record_class(type).all
     end
 
+    # Given a resource identifier, finds or builds a resource
+    #
+    # @param [Hash] resource_identifier the resource identifier for the resource
+    # @return [ActiveRecord::Base] the found or built resource for the relationship
+    def record_for_resource_identifier(resource_identifier)
+      if (type = resource_identifier[:type])
+        # { type: '...', id: '...' }
+        if (id = resource_identifier[:id])
+          begin
+            get_record!(
+              type,
+              Caprese.config.resource_primary_key,
+              id
+            )
+          rescue RecordNotFoundError => e
+            raise e unless record_scope(type.to_sym).is_a?(ActiveRecord::NullRelation)
+          end
+
+          # { type: '...', attributes: { ... } }
+        elsif contains_constructable_data?(resource_identifier)
+          record_scope(type.to_sym).build
+
+          # { type: '...' }
+        else
+          raise RequestDocumentInvalidError.new(field: :base)
+        end
+      else
+        # { id: '...' } && { attributes: { ... } }
+        raise RequestDocumentInvalidError.new(field: :type)
+      end
+    end
+
     # Gets a record in a scope using a column/value to search by
     #
     # @example

data/lib/caprese/controller/concerns/relationships.rb

@@ -228,43 +228,58 @@ module Caprese
     #
     # PATCH/POST/DELETE /api/v1/:controller/:id/relationships/:relationship
     def update_relationship_definition
+      successful = false
+
       if queried_association &&
         flattened_keys_for(permitted_params_for(:update)).include?(params[:relationship].to_sym)
+        relationship_name = queried_association.reflection.name
 
-        relationship_resources =
-          Array.wrap(params[:data]).map do |resource_identifier|
-            get_record!(
-              resource_identifier[:type],
-              column = self.config.resource_primary_key,
-              resource_identifier[column]
-            )
-          end
+        relationship_resources = []
+        begin
+          relationship_resources = Array.wrap(records_for_relationship(
+            queried_record,
+            [],
+            relationship_name,
+            data_params
+          ))
+        rescue ActionController::ParameterMissing => e
+          # Only PATCH requests are allowed to have no :data (when clearing relationship)
+          raise e unless request.patch?
+        rescue Caprese::RecordNotFoundError => e
+          raise RequestDocumentInvalidError.new(field: :base, code: :not_found, t: e.t.slice(:value))
+        end
 
-        relationship_name = queried_association.reflection.name
+        # Validate that if we assign queried_record as the inverse of the relationship, the relationship records are
+        # still valid
+        if !request.delete? && (inverse_reflection = queried_record.class.reflect_on_association(relationship_name).inverse_of)
+          relationship_resources.each { |r| r.send("#{inverse_reflection.name}=", queried_record) }
+        end
 
-        successful =
-          case queried_association.reflection.macro
-          when :has_many
-            if request.patch?
-              queried_record.send("#{relationship_name}=", relationship_resources)
-            elsif request.post?
-              queried_record.send(relationship_name).push relationship_resources
-            elsif request.delete?
-              queried_record.send(relationship_name).delete relationship_resources
-            end
-          when :has_one
-            if request.patch?
-              queried_record.send("#{relationship_name}=", relationship_resources[0])
-              relationship_resources[0].save if relationship_resources[0].present?
-            end
-          when :belongs_to
-            if request.patch?
-              queried_record.send("#{relationship_name}=", relationship_resources[0])
-              queried_record.save
+        if relationship_resources.all?(&:valid?)
+          successful =
+            case queried_association.reflection.macro
+            when :has_many
+              if request.patch?
+                queried_record.send("#{relationship_name}=", relationship_resources)
+              elsif request.post?
+                queried_record.send(relationship_name).push relationship_resources
+              elsif request.delete?
+                queried_record.send(relationship_name).delete relationship_resources
+              end
+
+              true
+            when :has_one
+              if request.patch?
+                queried_record.send("#{relationship_name}=", relationship_resources[0])
+                relationship_resources[0].save if relationship_resources[0].present?
+              end
+            when :belongs_to
+              if request.patch?
+                queried_record.send("#{relationship_name}=", relationship_resources[0])
+                queried_record.save
+              end
             end
-          end
-      else
-        successful = false
+        end
       end
 
       if successful

data/lib/caprese/error.rb

@@ -1,7 +1,7 @@
 # TODO: Remove in favor of Rails 5 error details and dynamically setting i18n_scope
 module Caprese
   class Error < StandardError
-    attr_reader :field, :code, :header
+    attr_reader :field, :code, :header, :t
 
     # Initializes a new error
     #
@@ -22,7 +22,9 @@ module Caprese
       @field = field
       @code = code
 
-      @t = t
+      # field is nil if :base
+      field_name = field || model
+      @t = { field: field_name.to_s, field_title: field_name.to_s.titleize }.merge t
 
       @header = { status: :bad_request }
     end
@@ -100,14 +102,6 @@ module Caprese
       }
     end
 
-    # Adds field and capitalized Field title to the translation params for every error
-    # and returns them
-    #
-    # @return [Hash] the full translation params of the error
-    def t
-      @t.merge(field: @field, field_title: @field.to_s.titleize)
-    end
-
     private
 
     # Checks whether or not a translation exists

data/lib/caprese/errors.rb

@@ -1,6 +1,21 @@
 require 'caprese/error'
 
 module Caprese
+  # Thrown when a request document contained an error that made it unprocessable
+  #
+  # @param [Symbol] field the field of the document that contained the error
+  # @param [Symbol] code the code for the error
+  # @param [Hash] t the translation params for the error
+  class RequestDocumentInvalidError < Error
+    attr_reader :document
+
+    def initialize(field: nil, code: :invalid, t: {})
+      super
+      @document = true
+      @header = { status: :unprocessable_entity }
+    end
+  end
+
   # Thrown when a record was attempted to be persisted and was invalidated
   #
   # @param [ActiveRecord::Base] record the record that is invalid

data/lib/caprese/serializer/concerns/relationships.rb

@@ -5,7 +5,7 @@ module Caprese
     module Relationships
       extend ActiveSupport::Concern
 
-      # Applies further scopes to a collection association when rendered as part of included document
+      # Applies further scopes to a singular or collection association when rendered as part of included document
       # @note Can be overridden to customize scoping at a per-relationship level
       #
       # @example
@@ -15,11 +15,13 @@ module Caprese
       #       scope.by_merchant(...)
       #     when :orders
       #       scope.by_user(...)
+      #     when :user
+      #       # change singular user response
       #     end
       #   end
       #
       # @param [String] name the name of the association
-      # @param [Relation] scope the scope corresponding to a collection association
+      # @param [Relation,Record] scope the scope corresponding to a collection association relation or singular record
       def relationship_scope(name, scope)
         scope
       end
@@ -31,10 +33,6 @@ module Caprese
             merge_serializer_option(name, options),
             &build_association_block(name)
           )
-
-          define_method name do
-            self.relationship_scope(name, object.send(object.class.caprese_unalias_field(name)))
-          end
         end
 
         def has_one(name, options = {}, &block)
@@ -109,7 +107,7 @@ module Caprese
               end
             end
 
-            :nil
+            serializer.relationship_scope(reflection_name, object.send(object.class.caprese_unalias_field(name)))
           end
         end
 

data/lib/caprese/serializer/error_serializer.rb

@@ -7,6 +7,10 @@ module Caprese
         object.try(:record).present?
       end
 
+      def document_errors?
+        object.try(:document).present?
+      end
+
       # Applies aliases to fields of RecordInvalid record's errors if aliases have been applied
       # @see controller/concerns/aliasing#engaged_field_aliases
       # Otherwise returns normal error fields as_json hash

data/lib/caprese/version.rb

@@ -1,3 +1,3 @@
 module Caprese
-  VERSION = '0.4.1'
+  VERSION = '0.5.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: caprese
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Nick Landgrebe
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-10-19 00:00:00.000000000 Z
+date: 2017-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers
@@ -272,3 +272,4 @@ signing_key:
 specification_version: 4
 summary: Opinionated Rails library for writing RESTful APIs
 test_files: []
+has_rdoc: