fun_with_json_api 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b39d90754d8cde854f6cd239634dd7415ff190b1
-  data.tar.gz: c7b727d00f76668701739f0e3a7f6abaf1438fce
+  metadata.gz: cbb6fa5d08ff453c7adef23b0c5a608e98897228
+  data.tar.gz: 1cb7de4f0f03fc553af3da253fea06bf33704cbe
 SHA512:
-  metadata.gz: b70869284cacc37b7915f8dc17d819184c722620e6350098f8ddfb22934cf15e6358c12ba455da2f3214f9c5969d7b1dfda0914eced2c9e0930675984d4284fe
-  data.tar.gz: 4af352dff332ab0770a74eed228c53e081da20f32925532c4546b774a61c41ba360e0247cb3fc4a8550c97822e7daebc2552247c5274a487d89c96b83d7e63ad
+  metadata.gz: be8824b7d81fc131fe50591cb9ff83495407d17f053845279add97a6eeccd8a473dba036df315f45db3b7097d84c9105fc6d1228308d195edc488dbfde054a9f
+  data.tar.gz: 2d5c7af796c4224c4868a66bf876d447337304ac9616da5a254f0253e4563dd003700774187f2075ef76e6d28b12551974c00c20fb203d559fa15a23929506fd

data/Rakefile

@@ -17,7 +17,10 @@ end
 Bundler::GemHelper.install_tasks
 
 require 'rubocop/rake_task'
-RuboCop::RakeTask.new
+require 'rubocop-rspec'
+RuboCop::RakeTask.new do |task|
+  task.requires << 'rubocop-rspec'
+end
 
 require 'rspec/core'
 require 'rspec/core/rake_task'

data/config/locales/fun_with_json_api.en.yml

@@ -2,12 +2,39 @@ en:
   fun_with_json_api:
     exceptions:
       invalid_document: 'Request json_api document is invalid'
-      invalid_attribute: 'Request json_api document attribute is invalid'
-      invalid_relationship: 'Request json_api document relationship is invalid'
+      invalid_document_identifier: 'Request json_api data id is invalid'
+      invalid_client_generated_identifier: 'Request json_api data id has already been used for an existing resource'
+      illegal_client_generated_identifier: 'Request json_api attempted to set an unsupported client-generated id'
+      invalid_document_type: 'Request json_api data type does not match endpoint'
+      missing_resource: 'Unable to find the requested resource'
+      invalid_attribute: 'Request json_api attribute data is invalid'
+      unknown_attribute: 'Request json_api attribute is unsupported by the current endpoint'
+      invalid_relationship: 'Request json_api relationship data is invalid'
       missing_relationship: 'Unable to find the requested relationship'
+      unknown_relationship: 'Request json_api relationship is unsupported by the current endpoint'
+      invalid_relationship_type: 'Request json_api relationship type does not match expected resource'
       invalid_boolean_attribute: "Boolean value should only be true, false, or null"
       invalid_date_attribute: "Date value should be in the format YYYY-MM-DD"
       invalid_datetime_attribute: "Datetime value should be a ISO 8601 datetime"
       invalid_decimal_attribute: "Decimal value must be a decimal number (i.e. 123.45)"
       invalid_float_attribute: "Float value must be a floating point number (i.e. 123.45)"
       invalid_integer_attribute: "Integer value must be a integer number (i.e. 123)"
+      invalid_string_attribute: 'String value must be a JSON String (i.e. "Example")'
+      invalid_uuid_v4_attribute: 'UUID value must be RFC 4122 Version 4 UUID (i.e. "f47ac10b-58cc-4372-a567-0e02b2c3d479")'
+    schema_validators:
+      document_id_does_not_match_resource: "Expected data id to match resource at endpoint: %{expected}"
+      document_type_does_not_match_endpoint: "Expected data type to be a '%{expected}' resource"
+      invalid_relationship_type_in_array: "Expected '%{relationship}' relationship to be an Array of '%{relationship_type}' resource identifiers"
+      invalid_relationship_type_in_hash: "Expected '%{relationship}' relationship to be null or a '%{relationship_type}' resource identifier Hash"
+      resource_id_can_not_be_client_generated: "The current endpoint does not allow you to set an id for a new '%{resource}' resource"
+      resource_id_has_already_been_assigned: "The provided id for a new '%{resource}' resource has already been used by another resource: %{id}"
+      unknown_attribute_for_resource: "The provided attribute '%{attribute}' can not be assigned to a '%{resource}' resource from the current endpoint"
+      unknown_relationship_for_resource: "The provided relationship '%{relationship}' can not be assigned to a '%{resource}' resource from the current endpoint"
+    find_resource_from_document:
+      invalid_document: "Expected data to be a Hash or null"
+      invalid_document_type: "Expected data type to be a '%{resource}' resource"
+      missing_resource: "Unable to find '%{resource}' with matching id: '%{resource_id}'"
+    find_collection_from_document:
+      invalid_document: "Expected data to be a Array of '%{resource}' resources"
+      invalid_document_type: "Expected '%{type}' to be a '%{resource}' resource"
+      missing_resource: "Unable to find '%{resource}' with matching id: '%{resource_id}'"

data/lib/fun_with_json_api.rb

@@ -3,22 +3,50 @@ require 'fun_with_json_api/attribute'
 
 require 'fun_with_json_api/pre_deserializer'
 require 'fun_with_json_api/deserializer'
-require 'fun_with_json_api/deserializer_config_builder'
+require 'fun_with_json_api/schema_validator'
+require 'fun_with_json_api/find_collection_from_document'
+require 'fun_with_json_api/find_resource_from_document'
 
 # Makes working with JSON:API fun!
 module FunWithJsonApi
+  MEDIA_TYPE = 'application/vnd.api+json'.freeze
+
   module_function
 
-  def deserialize(api_document, deserializer_class, options = {})
+  def deserialize(api_document, deserializer_class, resource = nil, options = {})
     # Prepare the deserializer and the expected config
     deserializer = deserializer_class.create(options)
 
     # Run through initial document structure validation and deserialization
     unfiltered = FunWithJsonApi::PreDeserializer.parse(api_document, deserializer)
 
+    # Check the document matches up with expected resource parameters
+    FunWithJsonApi::SchemaValidator.check(api_document, deserializer, resource)
+
     # Ensure document matches schema, and sanitize values
     deserializer.sanitize_params(unfiltered)
   end
+
+  def deserialize_resource(api_document, deserializer_class, resource, options = {})
+    raise ArgumentError, 'resource cannot be nil' if resource.nil?
+    deserialize(api_document, deserializer_class, resource, options)
+  end
+
+  def find_resource(api_document, deserializer_class, options = {})
+    # Prepare the deserializer for loading a resource
+    deserializer = deserializer_class.create(options.merge(attributes: [], relationships: []))
+
+    # Load the resource from the document id
+    FunWithJsonApi::FindResourceFromDocument.find(api_document, deserializer)
+  end
+
+  def find_collection(api_document, deserializer_class, options = {})
+    # Prepare the deserializer for loading a resource
+    deserializer = deserializer_class.create(options.merge(attributes: [], relationships: []))
+
+    # Load the collection from the document
+    FunWithJsonApi::FindCollectionFromDocument.find(api_document, deserializer)
+  end
 end
 
 require 'fun_with_json_api/railtie' if defined?(Rails)

data/lib/fun_with_json_api/action_controller_extensions/serialization.rb

@@ -0,0 +1,18 @@
+module FunWithJsonApi
+  module ActionControllerExtensions
+    module Serialization
+      # Overrides the dynamic render json_api methods to use ActiveModelSerializer
+      [:_render_option_json_api, :_render_with_renderer_json_api].each do |renderer_method|
+        define_method renderer_method do |resource, options|
+          options.fetch(:adapter) { options[:adapter] ||= :json_api }
+          options.fetch(:serialization_context) do
+            options[:serialization_context] ||=
+              ActiveModelSerializers::SerializationContext.new(request)
+          end
+          serializable_resource = get_serializer(resource, options)
+          super(serializable_resource, options)
+        end
+      end
+    end
+  end
+end

data/lib/fun_with_json_api/attribute.rb

@@ -16,8 +16,8 @@ module FunWithJsonApi
     def initialize(name, options = {})
       raise ArgumentError, 'name cannot be blank!' unless name.present?
 
-      @name = name
-      @as = options.fetch(:as, name)
+      @name = name.to_sym
+      @as = options.fetch(:as, name).to_sym
     end
 
     def call(value)
@@ -29,7 +29,7 @@ module FunWithJsonApi
     end
 
     def param_value
-      as.to_sym
+      as
     end
   end
 end

data/lib/fun_with_json_api/attributes/relationship.rb

@@ -10,18 +10,17 @@ module FunWithJsonApi
         new(name, deserializer_class_or_callable, options)
       end
 
-      delegate :id_param,
-               :type,
-               :resource_class,
-               to: :deserializer
+      attr_reader :deserializer_class
+      attr_reader :options
+      delegate :type, to: :deserializer
 
       def initialize(name, deserializer_class, options = {})
         super(name, options)
         @deserializer_class = deserializer_class
-      end
-
-      def deserializer
-        @deserializer ||= create_deserializer_from_deserializer_class
+        @options = options.reverse_merge(
+          attributes: [],
+          relationships: []
+        )
       end
 
       def call(id_value)
@@ -29,44 +28,59 @@ module FunWithJsonApi
           raise build_invalid_relationship_error(id_value)
         end
 
-        resource_class.find_by!(id_param => id_value).try(:id) if id_value
-      rescue ActiveRecord::RecordNotFound => e
-        raise convert_record_not_found_error(e, id_value)
+        resource = deserializer.load_resource_from_id_value(id_value)
+        return resource.id if resource
+
+        raise build_missing_relationship_error(id_value)
+      end
+
+      # rubocop:disable Style/PredicateName
+
+      def has_many?
+        false
       end
 
+      # rubocop:enable Style/PredicateName
+
       def param_value
         :"#{as}_id"
       end
 
+      def deserializer
+        @deserializer ||= build_deserializer_from_options
+      end
+
       private
 
-      # Creates a new Deserializer from the deserializer class
-      def create_deserializer_from_deserializer_class
+      def build_deserializer_from_options
         if @deserializer_class.respond_to?(:call)
           @deserializer_class.call
         else
           @deserializer_class
-        end.create(
-          attributes: [],
-          relationships: []
-        )
+        end.create(options)
       end
 
       def build_invalid_relationship_error(id_value)
-        exception_message = "#{name} relationship should contain a single '#{type}' data hash"
+        exception_message = "#{name} relationship should contain a single '#{deserializer.type}'"\
+                            ' data hash'
         payload = ExceptionPayload.new
         payload.pointer = "/data/relationships/#{name}"
         payload.detail = exception_message
         Exceptions::InvalidRelationship.new(exception_message + ": #{id_value.inspect}", payload)
       end
 
-      def convert_record_not_found_error(exception, id_value)
+      def build_missing_relationship_error(id_value, message = nil)
+        message ||= missing_resource_debug_message(id_value)
         payload = ExceptionPayload.new
         payload.pointer = "/data/relationships/#{name}/id"
-        payload.detail = "Unable to find '#{type}' with matching id: #{id_value.inspect}"
-        exception_message = "Couldn't find #{resource_class} where "\
-                            "#{id_param} = #{id_value.inspect}: #{exception.message}"
-        Exceptions::MissingRelationship.new(exception_message, payload)
+        payload.detail = "Unable to find '#{deserializer.type}' with matching id"\
+                         ": #{id_value.inspect}"
+        Exceptions::MissingRelationship.new(message, payload)
+      end
+
+      def missing_resource_debug_message(id_value)
+        "Couldn't find #{deserializer.resource_class.name}"\
+        " where #{deserializer.id_param} = #{id_value.inspect}"
       end
     end
   end

data/lib/fun_with_json_api/attributes/relationship_collection.rb

@@ -5,22 +5,19 @@ module FunWithJsonApi
         new(name, deserializer_class_or_callable, options)
       end
 
-      delegate :id_param,
-               :type,
-               :resource_class,
-               to: :deserializer
+      attr_reader :deserializer_class
+      attr_reader :options
+      delegate :type, to: :deserializer
 
       def initialize(name, deserializer_class, options = {})
         super(name, options.reverse_merge(as: name.to_s.singularize.to_sym))
         @deserializer_class = deserializer_class
+        @options = options.reverse_merge(
+          attributes: [],
+          relationships: []
+        )
 
-        if as.to_s != as.to_s.singularize
-          raise ArgumentError, "Use a singular relationship as value: {as: :#{as.to_s.singularize}}"
-        end
-      end
-
-      def deserializer
-        @deserializer ||= create_deserializer_from_deserializer_class
+        check_as_attribute_is_singular!
       end
 
       # Expects an array of id values for a nested collection
@@ -29,7 +26,7 @@ module FunWithJsonApi
           raise build_invalid_relationship_collection_error(values)
         end
 
-        collection = resource_class.where(id_param => values)
+        collection = deserializer.load_collection_from_id_values(values)
 
         # Ensure the collection size matches
         expected_size = values.size
@@ -42,35 +39,50 @@ module FunWithJsonApi
         convert_collection_to_ids(collection)
       end
 
+      # rubocop:disable Style/PredicateName
+
+      def has_many?
+        true
+      end
+
+      # rubocop:enable Style/PredicateName
+
       # User the singular of `as` that is how AMS converts the value
       def param_value
         :"#{as}_ids"
       end
 
+      def deserializer
+        @deserializer ||= build_deserializer_from_options
+      end
+
       private
 
+      def build_deserializer_from_options
+        if @deserializer_class.respond_to?(:call)
+          @deserializer_class.call
+        else
+          @deserializer_class
+        end.create(options)
+      end
+
+      def check_as_attribute_is_singular!
+        if as.to_s != as.to_s.singularize
+          raise ArgumentError, "Use a singular relationship as value: {as: :#{as.to_s.singularize}}"
+        end
+      end
+
       def convert_collection_to_ids(collection)
         if collection.respond_to? :pluck
           # Well... pluck+arel doesn't work with SQLite, but select at least is safe
-          collection = collection.select(resource_class.arel_table[:id])
+          collection = collection.select(deserializer.resource_class.arel_table[:id])
         end
         collection.map(&:id)
       end
 
-      # Creates a new Deserializer from the deserializer class
-      def create_deserializer_from_deserializer_class
-        if @deserializer_class.respond_to?(:call)
-          @deserializer_class.call
-        else
-          @deserializer_class
-        end.create(
-          attributes: [],
-          relationships: []
-        )
-      end
-
       def build_invalid_relationship_collection_error(values)
-        exception_message = "#{name} relationship should contain a array of '#{type}' data"
+        exception_message = "#{name} relationship should contain a array of"\
+                            " '#{deserializer.type}' data"
         payload = ExceptionPayload.new
         payload.pointer = "/data/relationships/#{name}"
         payload.detail = exception_message
@@ -78,21 +90,26 @@ module FunWithJsonApi
       end
 
       def build_missing_relationship_error_from_collection(collection, values)
-        collection_values = collection.map { |resource| resource.public_send(id_param).to_s }
-        missing_values = values.reject { |value| collection_values.include?(value.to_s) }
-        payload = missing_values.map do |value|
-          build_missing_relationship_payload(value)
-        end
-        exception_message = "Couldn't find #{resource_class} items with "\
-                            "#{id_param} in #{missing_values.inspect}"
+        collection_ids = deserializer.format_collection_ids(collection)
+
+        payload = build_missing_relationship_payload(collection_ids, values)
+
+        missing_values = values.reject { |value| collection_ids.include?(value.to_s) }
+        exception_message = "Couldn't find #{deserializer.resource_class} items with "\
+                            "#{deserializer.id_param} in #{missing_values.inspect}"
         Exceptions::MissingRelationship.new(exception_message, payload)
       end
 
-      def build_missing_relationship_payload(value)
-        ExceptionPayload.new.tap do |payload|
-          payload.pointer = "/data/relationships/#{name}/id"
-          payload.detail = "Unable to find '#{type}' with matching id: #{value.inspect}"
-        end
+      def build_missing_relationship_payload(collection_ids, values)
+        values.each_with_index.map do |resource_id, index|
+          next if collection_ids.include?(resource_id)
+
+          ExceptionPayload.new.tap do |payload|
+            payload.pointer = "/data/relationships/#{name}/#{index}/id"
+            payload.detail = "Unable to find '#{deserializer.type}' with matching id"\
+                             ": \"#{resource_id}\""
+          end
+        end.reject(&:nil?)
       end
     end
   end

data/lib/fun_with_json_api/attributes/string_attribute.rb

@@ -2,7 +2,18 @@ module FunWithJsonApi
   module Attributes
     class StringAttribute < Attribute
       def call(value)
-        value.to_s if value
+        return value if value.nil? || value.is_a?(String)
+
+        raise build_invalid_attribute_error(value)
+      end
+
+      private
+
+      def build_invalid_attribute_error(value)
+        payload = ExceptionPayload.new
+        payload.detail = I18n.t('fun_with_json_api.exceptions.invalid_string_attribute')
+        payload.pointer = "/data/attributes/#{name}"
+        Exceptions::InvalidAttribute.new("Value is not a string: #{value.class.name}", payload)
       end
     end
   end

data/lib/fun_with_json_api/attributes/uuid_v4_attribute.rb

@@ -0,0 +1,27 @@
+module FunWithJsonApi
+  module Attributes
+    # Attribute that only accepts a properly generated and formatted UUID version 4
+    # as described in RFC 4122
+    class UuidV4Attribute < Attribute
+      # http://blog.arkency.com/2014/10/how-to-start-using-uuid-in-activerecord-with-postgresql/
+      UUID_V4_REGEX = /\A[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}\z/
+
+      def call(value)
+        return value if value.nil? || value =~ UUID_V4_REGEX
+
+        raise build_invalid_attribute_error(value)
+      end
+
+      private
+
+      def build_invalid_attribute_error(value)
+        payload = ExceptionPayload.new
+        payload.detail = I18n.t('fun_with_json_api.exceptions.invalid_uuid_v4_attribute')
+        payload.pointer = "/data/attributes/#{name}"
+        Exceptions::InvalidAttribute.new(
+          "Value is not a RFC 4122 Version 4 UUID: #{value.class.name}", payload
+        )
+      end
+    end
+  end
+end