fun_with_json_api 0.0.2 → 0.0.3

data/lib/fun_with_json_api/find_resource_from_document.rb

@@ -0,0 +1,112 @@
+module FunWithJsonApi
+  class FindResourceFromDocument
+    def self.find(*args)
+      new(*args).find
+    end
+
+    private_class_method :new
+
+    attr_reader :api_document
+    attr_reader :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?
+
+      # Resource is being set to nil/null
+      return nil if document_is_null_resource?
+
+      # Ensure the document matches the expected resource
+      raise build_invalid_document_type_error unless document_matches_resource_type?
+
+      # Load resource from id value
+      deserializer.load_resource_from_id_value(document_id).tap do |resource|
+        raise build_missing_resource_error if resource.nil?
+      end
+    end
+
+    def document_id
+      @document_id ||= api_document['data']['id']
+    end
+
+    def document_type
+      @document_type ||= api_document['data']['type']
+    end
+
+    def resource_type
+      @resource_type ||= deserializer.type
+    end
+
+    def document_is_valid?
+      api_document.key?('data') && (
+        api_document['data'].is_a?(Hash) || document_is_null_resource?
+      )
+    end
+
+    def document_is_null_resource?
+      api_document['data'].nil?
+    end
+
+    def document_matches_resource_type?
+      resource_type == document_type
+    end
+
+    private
+
+    def build_invalid_document_error
+      payload = ExceptionPayload.new
+      payload.pointer = '/data'
+      payload.detail = document_is_invalid_message
+      Exceptions::InvalidDocument.new(
+        "Expected root data element with hash or null: #{api_document.inspect}",
+        payload
+      )
+    end
+
+    def build_invalid_document_type_error
+      message = "'#{document_type}' did not match expected resource type: '#{resource_type}'"
+      payload = ExceptionPayload.new(
+        detail: document_type_does_not_match_endpoint_message
+      )
+      Exceptions::InvalidDocumentType.new(message, payload)
+    end
+
+    def build_missing_resource_error
+      deserializer_name = deserializer.class.name || 'Deserializer'
+      message = "#{deserializer_name} was unable to find resource by '#{deserializer.id_param}'"\
+                ": '#{document_id}'"
+      payload = ExceptionPayload.new
+      payload.pointer = '/data/id'
+      payload.detail = missing_resource_message
+      Exceptions::MissingResource.new(message, payload)
+    end
+
+    def document_is_invalid_message
+      I18n.t(
+        :invalid_document,
+        scope: 'fun_with_json_api.find_resource_from_document'
+      )
+    end
+
+    def document_type_does_not_match_endpoint_message
+      I18n.t(
+        :invalid_document_type,
+        resource: resource_type,
+        scope: 'fun_with_json_api.find_resource_from_document'
+      )
+    end
+
+    def missing_resource_message
+      I18n.t(
+        :missing_resource,
+        resource: resource_type,
+        resource_id: document_id,
+        scope: 'fun_with_json_api.find_resource_from_document'
+      )
+    end
+  end
+end

data/lib/fun_with_json_api/pre_deserializer.rb

@@ -1,4 +1,5 @@
 require 'active_model_serializers'
+require 'fun_with_json_api/deserializer_config_builder'
 
 module FunWithJsonApi
   # Converts a json_api document into a rails compatible hash.

data/lib/fun_with_json_api/railtie.rb

@@ -1,9 +1,38 @@
 require 'fun_with_json_api/controller_methods'
+require 'fun_with_json_api/action_controller_extensions/serialization'
+
+Mime::Type.register FunWithJsonApi::MEDIA_TYPE, :json_api
 
 module FunWithJsonApi
   # Mountable engine for fun with json_api
   class Railtie < Rails::Railtie
-    initializer 'fun_with_json_api.add_locales' do
+    initializer :register_json_api_mime_type do
+      parsers =
+        if Rails::VERSION::MAJOR >= 5
+          ActionDispatch::Http::Parameters
+        else
+          ActionDispatch::ParamsParser
+        end
+
+      parsers::DEFAULT_PARSERS[Mime::Type.lookup(FunWithJsonApi::MEDIA_TYPE)] = lambda do |body|
+        data = JSON.parse(body)
+        data = { _json: data } unless data.is_a?(Hash)
+        data.with_indifferent_access
+      end
+    end
+    initializer :register_json_api_renderer do
+      ActionController::Renderers.add :json_api do |json, options|
+        json = json.to_json(options) unless json.is_a?(String)
+        self.content_type ||= Mime::Type.lookup(FunWithJsonApi::MEDIA_TYPE)
+        json
+      end
+    end
+    initializer :register_json_api_serializers do
+      ActiveSupport.on_load(:action_controller) do
+        include(FunWithJsonApi::ActionControllerExtensions::Serialization)
+      end
+    end
+    initializer :add_json_api_locales do
       translations = File.expand_path('../../../config/locales/**/*.{rb,yml}', __FILE__)
       Dir.glob(translations) { |f| config.i18n.load_path << f.to_s }
     end

data/lib/fun_with_json_api/schema_validator.rb

@@ -0,0 +1,47 @@
+require 'fun_with_json_api/exception'
+
+module FunWithJsonApi
+  class SchemaValidator
+    def self.check(api_document, deserializer, resource)
+      new(api_document, deserializer, resource).check
+    end
+
+    private_class_method :new
+
+    attr_reader :api_document
+    attr_reader :deserializer
+    attr_reader :resource
+
+    def initialize(api_document, deserializer, resource)
+      @api_document = api_document.deep_stringify_keys
+      @deserializer = deserializer
+      @resource = resource
+    end
+
+    def check
+      FunWithJsonApi::SchemaValidators::CheckDocumentTypeMatchesResource.call(self)
+      FunWithJsonApi::SchemaValidators::CheckDocumentIdMatchesResource.call(self)
+      FunWithJsonApi::SchemaValidators::CheckAttributes.call(api_document, deserializer)
+      FunWithJsonApi::SchemaValidators::CheckRelationships.call(api_document, deserializer)
+    end
+
+    def document_id
+      @document_id ||= api_document['data']['id']
+    end
+
+    def document_type
+      @document_type ||= api_document['data']['type']
+    end
+
+    def resource_id
+      @resource_id ||= resource.send(deserializer.id_param).to_s
+    end
+
+    def resource_type
+      @resource_type ||= deserializer.type
+    end
+  end
+end
+
+# Load known Schema Validators
+Dir["#{File.dirname(__FILE__)}/schema_validators/**/*.rb"].each { |f| require f }

data/lib/fun_with_json_api/schema_validators/check_attributes.rb

@@ -0,0 +1,52 @@
+module FunWithJsonApi
+  module SchemaValidators
+    class CheckAttributes
+      def self.call(api_document, deserializer)
+        new(api_document, deserializer).call
+      end
+
+      attr_reader :api_document
+      attr_reader :deserializer
+
+      def initialize(api_document, deserializer)
+        @api_document = api_document
+        @deserializer = deserializer
+      end
+
+      def call
+        attributes = api_document['data'].fetch('attributes', {}).keys
+        unknown = attributes.reject { |attribute| resource_attributes.include?(attribute) }
+
+        return true if unknown.empty?
+
+        raise build_unknown_attribute_error(unknown)
+      end
+
+      def resource_attributes
+        @resource_attributes ||= deserializer.attributes.map(&:name).map(&:to_s)
+      end
+
+      private
+
+      def build_unknown_attribute_error(unknown_attributes)
+        payload = unknown_attributes.map do |attribute|
+          ExceptionPayload.new(
+            detail: unknown_attribute_error(attribute),
+            pointer: "/data/attributes/#{attribute}"
+          )
+        end
+        message = 'Unknown attributes were provided by endpoint'
+        FunWithJsonApi::Exceptions::UnknownAttribute.new(message, payload)
+      end
+
+      def unknown_attribute_error(attribute)
+        I18n.t(
+          :unknown_attribute_for_resource,
+          attribute: attribute,
+          resource: deserializer.type,
+          scope: 'fun_with_json_api.schema_validators'
+        )
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/schema_validators/check_document_id_matches_resource.rb

@@ -0,0 +1,96 @@
+module FunWithJsonApi
+  module SchemaValidators
+    class CheckDocumentIdMatchesResource
+      def self.call(schema_validator)
+        new(schema_validator).call
+      end
+
+      attr_reader :schema_validator
+      delegate :resource,
+               :document_id,
+               :resource_id,
+               :resource_type,
+               :deserializer,
+               to: :schema_validator
+
+      def initialize(schema_validator)
+        @schema_validator = schema_validator
+      end
+
+      def call
+        if resource.try(:persisted?)
+          # Ensure correct update document is being sent
+          check_resource_id_matches_document_id
+        elsif document_id
+          # Ensure correct create document is being sent
+          check_resource_id_can_be_client_generated
+          check_resource_id_has_not_already_been_used
+        end
+      end
+
+      def check_resource_id_matches_document_id
+        if document_id != resource_id
+          message = "resource id '#{resource_id}' does not match the expected id for"\
+                    " '#{resource_type}': '#{document_id}'"
+          payload = ExceptionPayload.new(
+            detail: document_id_does_not_match_resource_message
+          )
+          raise Exceptions::InvalidDocumentIdentifier.new(message, payload)
+        end
+      end
+
+      def check_resource_id_can_be_client_generated
+        # Ensure id has been provided as an attribute
+        if deserializer.attributes.none? { |attribute| attribute.name == :id }
+          deserializer_name = deserializer.class.name || 'Deserializer'
+          message = "id parameter for '#{resource_type}' cannot be set"\
+                    " as it has not been defined as a #{deserializer_name} attribute"
+          payload = ExceptionPayload.new(
+            detail: resource_id_can_not_be_client_generated_message
+          )
+          raise Exceptions::IllegalClientGeneratedIdentifier.new(message, payload)
+        end
+      end
+
+      def check_resource_id_has_not_already_been_used
+        if (existing = deserializer.load_resource_from_id_value(document_id))
+          deserializer_class = deserializer.class.name || 'Deserializer'
+          message = "#{deserializer_class}#load_resource_from_id_value for '#{resource_type}' has"\
+                    ' found a existing resource matching document id'\
+                    ": #{existing.class.name}##{existing.id}"
+          payload = ExceptionPayload.new(
+            detail: resource_id_has_already_been_used_message
+          )
+          raise Exceptions::InvalidClientGeneratedIdentifier.new(message, payload)
+        end
+      end
+
+      private
+
+      def document_id_does_not_match_resource_message
+        I18n.t(
+          :document_id_does_not_match_resource,
+          expected: resource_id,
+          scope: 'fun_with_json_api.schema_validators'
+        )
+      end
+
+      def resource_id_can_not_be_client_generated_message
+        I18n.t(
+          :resource_id_can_not_be_client_generated,
+          resource: resource_type,
+          scope: 'fun_with_json_api.schema_validators'
+        )
+      end
+
+      def resource_id_has_already_been_used_message
+        I18n.t(
+          :resource_id_has_already_been_assigned,
+          id: document_id,
+          resource: resource_type,
+          scope: 'fun_with_json_api.schema_validators'
+        )
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/schema_validators/check_document_type_matches_resource.rb

@@ -0,0 +1,40 @@
+module FunWithJsonApi
+  module SchemaValidators
+    class CheckDocumentTypeMatchesResource
+      def self.call(schema_validator)
+        new(schema_validator).call
+      end
+
+      attr_reader :schema_validator
+      delegate :document_type,
+               :resource_type,
+               :deserializer,
+               to: :schema_validator
+
+      def initialize(schema_validator)
+        @schema_validator = schema_validator
+      end
+
+      def call
+        if document_type != resource_type
+          message = "'#{document_type}' does not match the expected resource"\
+                    ": #{resource_type}"
+          payload = ExceptionPayload.new(
+            detail: document_type_does_not_match_endpoint_message
+          )
+          raise Exceptions::InvalidDocumentType.new(message, payload)
+        end
+      end
+
+      private
+
+      def document_type_does_not_match_endpoint_message
+        I18n.t(
+          :document_type_does_not_match_endpoint,
+          expected: resource_type,
+          scope: 'fun_with_json_api.schema_validators'
+        )
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/schema_validators/check_relationships.rb

@@ -0,0 +1,127 @@
+module FunWithJsonApi
+  module SchemaValidators
+    class CheckRelationships
+      def self.call(api_document, deserializer)
+        new(api_document, deserializer).call
+      end
+
+      attr_reader :api_document
+      attr_reader :deserializer
+
+      def initialize(api_document, deserializer)
+        @api_document = api_document
+        @deserializer = deserializer
+      end
+
+      def call
+        relationships = api_document['data'].fetch('relationships', {})
+
+        check_for_unknown_relationships! relationships.keys
+        check_for_invalid_relationship_type! relationships
+
+        true
+      end
+
+      def check_for_unknown_relationships!(relationship_keys)
+        unknown = relationship_keys.reject { |rel| resource_relationships.include?(rel) }
+        return if unknown.empty?
+
+        raise build_unknown_relationship_error(unknown)
+      end
+
+      def check_for_invalid_relationship_type!(relationships_hash)
+        payload = build_invalid_relationship_type_payload(relationships_hash)
+        return if payload.empty?
+
+        message = 'A relationship received data with an incorrect type'
+        raise FunWithJsonApi::Exceptions::InvalidRelationshipType.new(message, payload)
+      end
+
+      def check_for_invalid_relationship_type_in_collection!(relationship, collection_data)
+        return unless collection_data.is_a?(Array)
+
+        collection_data.each_with_index.map do |item, index|
+          next if item['type'] == relationship.type
+
+          build_invalid_collection_item_payload(relationship, index)
+        end
+      end
+
+      def check_for_invalid_relationship_type_in_relationship!(relationship, relationship_data)
+        return unless relationship_data.is_a?(Hash)
+        return if relationship_data['type'] == relationship.type
+
+        build_invalid_relationship_item_payload(relationship)
+      end
+
+      def resource_relationships
+        @resource_relationships ||= deserializer.relationships.map(&:name).map(&:to_s)
+      end
+
+      private
+
+      def invalid_relationship_type_in_array_message(relationship)
+        I18n.t(
+          :invalid_relationship_type_in_array,
+          relationship: relationship.name,
+          relationship_type: relationship.type,
+          scope: 'fun_with_json_api.schema_validators'
+        )
+      end
+
+      def invalid_relationship_type_in_hash_message(relationship)
+        I18n.t(
+          :invalid_relationship_type_in_hash,
+          relationship: relationship.name,
+          relationship_type: relationship.type,
+          scope: 'fun_with_json_api.schema_validators'
+        )
+      end
+
+      def build_invalid_relationship_type_payload(relationships_hash)
+        deserializer.relationships.map do |relationship|
+          data = relationships_hash.fetch(relationship.name.to_s)['data']
+          if relationship.has_many?
+            check_for_invalid_relationship_type_in_collection!(relationship, data)
+          else
+            check_for_invalid_relationship_type_in_relationship!(relationship, data)
+          end
+        end.flatten.compact
+      end
+
+      def build_invalid_collection_item_payload(relationship, index)
+        ExceptionPayload.new(
+          detail: invalid_relationship_type_in_array_message(relationship),
+          pointer: "/data/relationships/#{relationship.name}/#{index}/type"
+        )
+      end
+
+      def build_invalid_relationship_item_payload(relationship)
+        ExceptionPayload.new(
+          detail: invalid_relationship_type_in_hash_message(relationship),
+          pointer: "/data/relationships/#{relationship.name}/type"
+        )
+      end
+
+      def build_unknown_relationship_error(unknown_relationships)
+        payload = unknown_relationships.map do |relationship|
+          ExceptionPayload.new(
+            detail: unknown_relationship_error(relationship),
+            pointer: "/data/relationships/#{relationship}"
+          )
+        end
+        message = 'Unknown relationships were provided by endpoint'
+        FunWithJsonApi::Exceptions::UnknownRelationship.new(message, payload)
+      end
+
+      def unknown_relationship_error(relationship)
+        I18n.t(
+          :unknown_relationship_for_resource,
+          relationship: relationship,
+          resource: deserializer.type,
+          scope: 'fun_with_json_api.schema_validators'
+        )
+      end
+    end
+  end
+end