fun_with_json_api 0.0.2 → 0.0.3

data/lib/fun_with_json_api/controller_methods.rb

@@ -3,7 +3,7 @@ require 'fun_with_json_api/exception_serializer'
 module FunWithJsonApi
   module ControllerMethods
     def render_fun_with_json_api_exception(exception)
-      render json: exception,
+      render json_api: exception,
              serializer: FunWithJsonApi::ExceptionSerializer,
              adapter: :json,
              status: exception.http_status

data/lib/fun_with_json_api/deserializer.rb

@@ -19,14 +19,28 @@ module FunWithJsonApi
     attr_reader :resource_class
 
     attr_reader :attributes
-    attr_reader :relationships
 
     def initialize(options = {})
       @id_param = options.fetch(:id_param) { self.class.id_param }
-      @type = options[:type]
+      @type = options.fetch(:type) { self.class.type }
       @resource_class = options[:resource_class]
-      @attributes = filter_attributes_by_name(options[:attributes], self.class.attributes)
-      @relationships = filter_attributes_by_name(options[:relationships], self.class.relationships)
+      @resource_collection = options[:resource_collection] if @type
+      load_attributes_from_options(options)
+      load_relationships_from_options(options)
+    end
+
+    # Loads a collection of of `resource_class` instances with `id_param` matching `id_values`
+    def load_collection_from_id_values(id_values)
+      resource_collection.where(id_param => id_values)
+    end
+
+    def format_collection_ids(collection)
+      collection.map { |resource| resource.public_send(id_param).to_s }
+    end
+
+    # Loads a single instance of `resource_class` with a `id_param` matching `id_value`
+    def load_resource_from_id_value(id_value)
+      resource_collection.find_by(id_param => id_value)
     end
 
     # Takes a parsed params hash from ActiveModelSerializers::Deserialization and sanitizes values
@@ -37,16 +51,47 @@ module FunWithJsonApi
       ]
     end
 
-    def type
-      @type ||= self.class.type
-    end
-
     def resource_class
       @resource_class ||= self.class.resource_class
     end
 
+    def resource_collection
+      @resource_collection ||= resource_class
+    end
+
+    def relationships
+      relationship_lookup.values
+    end
+
+    def relationship_for(resource_name)
+      relationship_lookup.fetch(resource_name)
+    end
+
     private
 
+    attr_reader :relationship_lookup
+
+    def load_attributes_from_options(options)
+      @attributes = filter_attributes_by_name(options[:attributes], self.class.attributes)
+    end
+
+    def load_relationships_from_options(options = {})
+      options_config = {}
+
+      # Filter resources and build an options hash for each
+      filter_relationships_by_name(
+        options[:relationships], self.class.relationship_names
+      ).each do |relationship|
+        options_config[relationship] = options.fetch(relationship, {})
+      end
+
+      # Build the relationships and store them into a lookup hash
+      @relationship_lookup = {}
+      self.class.build_relationships(options_config).each do |relationship|
+        @relationship_lookup[relationship.name] = relationship
+      end
+    end
+
     def filter_attributes_by_name(attribute_names, attributes)
       if attribute_names
         attributes.keep_if { |attribute| attribute_names.include?(attribute.name) }
@@ -55,6 +100,14 @@ module FunWithJsonApi
       end
     end
 
+    def filter_relationships_by_name(relationship_names, relationships)
+      if relationship_names
+        relationships.keep_if { |relationship| relationship_names.include?(relationship) }
+      else
+        relationships
+      end
+    end
+
     # Calls <attribute.as> on the current instance, override the #<as> method to change loading
     def serialize_attribute_values(attributes, params)
       attributes.select { |attribute| params.key?(attribute.param_value) }

data/lib/fun_with_json_api/deserializer_class_methods.rb

@@ -3,9 +3,13 @@ require 'fun_with_json_api/attribute'
 module FunWithJsonApi
   # Provides a basic DSL for defining a FunWithJsonApi::Deserializer
   module DeserializerClassMethods
-    def id_param(id_param = nil)
-      @id_param = id_param if id_param
-      @id_param || :id
+    def id_param(id_param = nil, format: false)
+      @id_param = id_param.to_sym if id_param
+      (@id_param || :id).tap do |param|
+        if format
+          attribute(:id, as: param, format: format) # Create a new id attribute
+        end
+      end
     end
 
     def type(type = nil)
@@ -39,7 +43,7 @@ module FunWithJsonApi
         deserializer_class_or_callable,
         options
       ).tap do |relationship|
-        add_parse_attribute_method(relationship)
+        add_parse_resource_method(relationship)
         relationships << relationship
       end
     end
@@ -52,26 +56,52 @@ module FunWithJsonApi
         deserializer_class_or_callable,
         options
       ).tap do |relationship|
-        add_parse_attribute_method(relationship)
+        add_parse_resource_method(relationship)
         relationships << relationship
       end
     end
 
     # rubocop:enable Style/PredicateName
 
-    def relationships
-      @relationships ||= []
+    def relationship_names
+      relationships.map(&:name)
+    end
+
+    def build_relationships(options)
+      options.map do |name, relationship_options|
+        relationship = relationships.detect { |rel| rel.name == name }
+        relationship.class.create(
+          relationship.name,
+          relationship.deserializer_class,
+          relationship_options.reverse_merge(relationship.options)
+        )
+      end
     end
 
     private
 
+    def relationships
+      @relationships ||= []
+    end
+
     def add_parse_attribute_method(attribute)
       define_method(attribute.sanitize_attribute_method) do |param_value|
         attribute.call(param_value)
       end
     end
 
+    def add_parse_resource_method(resource)
+      define_method(resource.sanitize_attribute_method) do |param_value|
+        relationship_for(resource.name).call(param_value)
+      end
+    end
+
     def type_from_class_name
+      if name.nil?
+        Rails.logger.warn 'Unable to determine type for anonymous Deserializer'
+        return nil
+      end
+
       resource_class_name = name.demodulize.sub(/Deserializer/, '').underscore
       if ActiveModelSerializers.config.jsonapi_resource_type == :singular
         resource_class_name.singularize

data/lib/fun_with_json_api/exceptions/illegal_client_generated_identifier.rb

@@ -0,0 +1,17 @@
+module FunWithJsonApi
+  module Exceptions
+    # A server MUST return 403 Forbidden in response to an unsupported request to create a resource
+    # with a client-generated ID.
+    class IllegalClientGeneratedIdentifier < FunWithJsonApi::Exception
+      EXCEPTION_CODE = 'illegal_client_generated_identifier'.freeze
+
+      def initialize(message, payload = ExceptionPayload.new)
+        payload.code ||= EXCEPTION_CODE
+        payload.title ||= I18n.t(EXCEPTION_CODE, scope: 'fun_with_json_api.exceptions')
+        payload.status ||= '403'
+        payload.pointer ||= '/data/id'
+        super
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/exceptions/invalid_client_generated_identifier.rb

@@ -0,0 +1,17 @@
+module FunWithJsonApi
+  module Exceptions
+    # A server MUST return 409 Conflict when processing a POST request to create a resource with a
+    # client-generated ID that already exists.
+    class InvalidClientGeneratedIdentifier < FunWithJsonApi::Exception
+      EXCEPTION_CODE = 'invalid_client_generated_identifier'.freeze
+
+      def initialize(message, payload = ExceptionPayload.new)
+        payload.code ||= EXCEPTION_CODE
+        payload.title ||= I18n.t(EXCEPTION_CODE, scope: 'fun_with_json_api.exceptions')
+        payload.status ||= '409'
+        payload.pointer ||= '/data/id'
+        super
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/exceptions/invalid_document_identifier.rb

@@ -0,0 +1,17 @@
+module FunWithJsonApi
+  module Exceptions
+    # A server MUST return 409 Conflict when processing a PATCH request in which the resource
+    # object's type and id do not match the server's endpoint
+    class InvalidDocumentIdentifier < FunWithJsonApi::Exception
+      EXCEPTION_CODE = 'invalid_document_identifier'.freeze
+
+      def initialize(message, payload = ExceptionPayload.new)
+        payload.code ||= EXCEPTION_CODE
+        payload.title ||= I18n.t(EXCEPTION_CODE, scope: 'fun_with_json_api.exceptions')
+        payload.status ||= '409'
+        payload.pointer ||= '/data/id'
+        super
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/exceptions/invalid_document_type.rb

@@ -0,0 +1,20 @@
+module FunWithJsonApi
+  module Exceptions
+    # A server MUST return 409 Conflict when processing a POST request in which the resource
+    # object's type is not among the type(s) that constitute the collection represented by the
+    # endpoint.
+    class InvalidDocumentType < FunWithJsonApi::Exception
+      EXCEPTION_CODE = 'invalid_document_type'.freeze
+
+      def initialize(message, payload = ExceptionPayload.new)
+        payload = Array.wrap(payload).each do |invalid|
+          invalid.code ||= EXCEPTION_CODE
+          invalid.title ||= I18n.t(EXCEPTION_CODE, scope: 'fun_with_json_api.exceptions')
+          invalid.status ||= '409'
+          invalid.pointer ||= '/data/type'
+        end
+        super
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/exceptions/invalid_relationship.rb

@@ -3,9 +3,11 @@ module FunWithJsonApi
     # Indicates a Supplied relationships value is not formatted correctly
     class InvalidRelationship < FunWithJsonApi::Exception
       def initialize(message, payload = ExceptionPayload.new)
-        payload.code ||= 'invalid_relationship'
-        payload.title ||= I18n.t(:invalid_relationship, scope: 'fun_with_json_api.exceptions')
-        payload.status ||= '400'
+        Array.wrap(payload).each do |invalid|
+          invalid.code ||= 'invalid_relationship'
+          invalid.title ||= I18n.t(:invalid_relationship, scope: 'fun_with_json_api.exceptions')
+          invalid.status ||= '400'
+        end
         super
       end
     end

data/lib/fun_with_json_api/exceptions/invalid_relationship_type.rb

@@ -0,0 +1,17 @@
+module FunWithJsonApi
+  module Exceptions
+    # Indicates a supplied relationships type does match expected values
+    class InvalidRelationshipType < FunWithJsonApi::Exception
+      ERROR_CODE = 'invalid_relationship_type'.freeze
+
+      def initialize(message, payload = ExceptionPayload.new)
+        Array.wrap(payload).each do |invalid|
+          invalid.code ||= ERROR_CODE
+          invalid.title ||= I18n.t(ERROR_CODE, scope: 'fun_with_json_api.exceptions')
+          invalid.status ||= '409'
+        end
+        super
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/exceptions/missing_resource.rb

@@ -0,0 +1,15 @@
+module FunWithJsonApi
+  module Exceptions
+    # Indicates a Resource or Collection item was not able to be found
+    class MissingResource < FunWithJsonApi::Exception
+      def initialize(message, payload = ExceptionPayload.new)
+        payload = Array.wrap(payload).each do |missing|
+          missing.code ||= 'missing_resource'
+          missing.title ||= I18n.t('missing_resource', scope: 'fun_with_json_api.exceptions')
+          missing.status ||= '404'
+        end
+        super
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/exceptions/unknown_attribute.rb

@@ -0,0 +1,15 @@
+module FunWithJsonApi
+  module Exceptions
+    # Indicates a supplied attribute value is unknown to the current deserializer
+    class UnknownAttribute < FunWithJsonApi::Exception
+      def initialize(message, payload = ExceptionPayload.new)
+        payload = Array.wrap(payload).each do |unknown|
+          unknown.code ||= 'unknown_attribute'
+          unknown.title ||= I18n.t(:unknown_attribute, scope: 'fun_with_json_api.exceptions')
+          unknown.status ||= '422'
+        end
+        super
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/exceptions/unknown_relationship.rb

@@ -0,0 +1,15 @@
+module FunWithJsonApi
+  module Exceptions
+    # Indicates a supplied relationship value is unknown to the current deserializer
+    class UnknownRelationship < FunWithJsonApi::Exception
+      def initialize(message, payload = ExceptionPayload.new)
+        payload = Array.wrap(payload).each do |unknown|
+          unknown.code ||= 'unknown_relationship'
+          unknown.title ||= I18n.t(:unknown_relationship, scope: 'fun_with_json_api.exceptions')
+          unknown.status ||= '422'
+        end
+        super
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/find_collection_from_document.rb

@@ -0,0 +1,124 @@
+module FunWithJsonApi
+  class FindCollectionFromDocument
+    def self.find(*args)
+      new(*args).find
+    end
+
+    private_class_method :new
+
+    attr_reader :api_document
+    attr_reader :deserializer
+    delegate :id_param, :id_param, :resource_class, to: :deserializer
+
+    def initialize(api_document, deserializer)
+      @api_document = api_document.deep_stringify_keys
+      @deserializer = deserializer
+    end
+
+    def find
+      raise build_invalid_document_error unless document_is_valid_collection?
+
+      # Skip the checks, no point running through them for an empty array
+      return [] if document_ids.empty?
+
+      # Ensure the document matches the expected resource
+      check_document_types_match_deserializer!
+
+      # Load resource from id value
+      deserializer.load_collection_from_id_values(document_ids).tap do |collection|
+        check_collection_contains_all_requested_resources!(collection)
+      end
+    end
+
+    def document_ids
+      @document_id ||= api_document['data'].map { |item| item['id'] }
+    end
+
+    def document_types
+      @document_type ||= api_document['data'].map { |item| item['type'] }.uniq
+    end
+
+    def resource_type
+      @resource_type ||= deserializer.type
+    end
+
+    def document_is_valid_collection?
+      api_document.key?('data') && api_document['data'].is_a?(Array)
+    end
+
+    private
+
+    def check_collection_contains_all_requested_resources!(collection)
+      if collection.size != document_ids.size
+        collection_ids = deserializer.format_collection_ids(collection)
+        raise build_missing_resources_error(collection_ids)
+      end
+    end
+
+    def check_document_types_match_deserializer!
+      invalid_document_types = document_types.reject { |type| type == resource_type }
+      raise build_invalid_document_types_error if invalid_document_types.any?
+    end
+
+    def build_invalid_document_error
+      payload = ExceptionPayload.new
+      payload.pointer = '/data'
+      payload.detail = 'Expected data to be an Array of resources'
+      Exceptions::InvalidDocument.new(
+        "Expected root data element with an Array: #{api_document.inspect}",
+        payload
+      )
+    end
+
+    def build_invalid_document_types_error
+      message = 'Expected type for each item to match expected resource type'\
+                ": '#{resource_type}'"
+      payload = api_document['data'].each_with_index.map do |data, index|
+        next if data['type'] == resource_type
+        ExceptionPayload.new(
+          pointer: "/data/#{index}/type",
+          detail: document_type_does_not_match_endpoint_message(data['type'])
+        )
+      end.reject(&:nil?)
+      Exceptions::InvalidDocumentType.new(message, payload)
+    end
+
+    def build_missing_resources_error(collection_ids)
+      payload = document_ids.each_with_index.map do |resource_id, index|
+        build_missing_resource_payload(collection_ids, resource_id, index)
+      end.reject(&:nil?)
+
+      missing_values = document_ids.reject { |value| collection_ids.include?(value.to_s) }
+      message = "Couldn't find #{resource_class} items with "\
+                "#{id_param} in #{missing_values.inspect}"
+      Exceptions::MissingResource.new(message, payload)
+    end
+
+    def build_missing_resource_payload(collection_ids, resource_id, index)
+      unless collection_ids.include?(resource_id)
+        ExceptionPayload.new(
+          pointer: "/data/#{index}/id",
+          detail: missing_resource_message(resource_id)
+        )
+      end
+    end
+
+    def document_type_does_not_match_endpoint_message(type)
+      I18n.t(
+        :invalid_document_type,
+        type: type,
+        resource: resource_type,
+        scope: 'fun_with_json_api.find_collection_from_document'
+      )
+    end
+
+    def missing_resource_message(resource_id)
+      I18n.t(
+        :missing_resource,
+        resource: resource_type,
+        resource_id: resource_id,
+        scope: 'fun_with_json_api.find_collection_from_document'
+      )
+    end
+  end
+end