Add validation error when data/type missing

Addresses #339

A few other things came up - one is that all requests, even reads, go
through the validator. Ideally the check is further upstream but I
tried to change the least amount of code while making this explicit.

The other is that I'm normalizing the params in the constructor, so
we can always deal with something normalized instead of worrying about
raw vs normalized. This has a downstream effect of changing the error
message for a Rails4-specific test you can see in the diff (if
anything, probably more correct now).

Author: Lee Richmond

lib/graphiti/request_validators/update_validator.rb

@@ -26,17 +26,17 @@ def required_payload?
           [:data, :type],
           [:data, :id]
         ].each do |required_attr|
-          attribute_mismatch(required_attr) unless @raw_params.dig(*required_attr)
+          attribute_mismatch(required_attr) unless @params.dig(*required_attr)
         end
         errors.blank?
       end
 
       def payload_matches_endpoint?
-        unless @raw_params.dig(:data, :id) == @raw_params.dig(:filter, :id)
+        unless @params.dig(:data, :id) == @params.dig(:filter, :id)
           attribute_mismatch([:data, :id])
         end
 
-        meta_type = @raw_params.dig(:data, :type)
+        meta_type = @params.dig(:data, :type)
 
         # NOTE: calling #to_s and comparing 2 strings is slower than
         # calling #to_sym and comparing 2 symbols. But pre ruby-2.2

lib/graphiti/request_validators/validator.rb

@@ -5,21 +5,31 @@ class Validator
 
       def initialize(root_resource, raw_params, action)
         @root_resource = root_resource
-        @raw_params = raw_params
+        @params = normalized_params(raw_params)
         @errors = Graphiti::Util::SimpleErrors.new(raw_params)
         @action = action
       end
 
       def validate
+        # Right now, all requests - even reads - go through the validator
+        # In the future these should have their own validation logic, but
+        # for now we can just bypass
+        return true unless @params.has_key?(:data)
+
         resource = @root_resource
-        if (meta_type = deserialized_payload.meta[:type].try(:to_sym))
-          if @root_resource.type != meta_type && @root_resource.polymorphic?
-            resource = @root_resource.class.resource_for_type(meta_type).new
+
+        if @params[:data].has_key?(:type)
+          if (meta_type = deserialized_payload.meta[:type].try(:to_sym))
+            if @root_resource.type != meta_type && @root_resource.polymorphic?
+              resource = @root_resource.class.resource_for_type(meta_type).new
+            end
           end
-        end
 
-        typecast_attributes(resource, deserialized_payload.attributes, deserialized_payload.meta[:payload_path])
-        process_relationships(resource, deserialized_payload.relationships, deserialized_payload.meta[:payload_path])
+          typecast_attributes(resource, deserialized_payload.attributes, deserialized_payload.meta[:payload_path])
+          process_relationships(resource, deserialized_payload.relationships, deserialized_payload.meta[:payload_path])
+        else
+          errors.add(:"data.type", :missing)
+        end
 
         errors.blank?
       end
@@ -33,14 +43,7 @@ def validate!
       end
 
       def deserialized_payload
-        @deserialized_payload ||= begin
-                                    payload = normalized_params
-                                    if payload[:data] && payload[:data][:type]
-                                      Graphiti::Deserializer.new(payload)
-                                    else
-                                      Graphiti::Deserializer.new({})
-                                    end
-                                  end
+        @deserialized_payload ||= Graphiti::Deserializer.new(@params)
       end
 
       private
@@ -86,8 +89,8 @@ def typecast_attributes(resource, attributes, payload_path)
         end
       end
 
-      def normalized_params
-        normalized = @raw_params
+      def normalized_params(raw_params)
+        normalized = raw_params
         if normalized.respond_to?(:to_unsafe_h)
           normalized = normalized.to_unsafe_h.deep_symbolize_keys
         end

spec/integration/rails/persistence_spec.rb

@@ -887,12 +887,12 @@ def self.model_name
                   code: "unprocessable_entity",
                   status: "422",
                   title: "Validation Error",
-                  detail: "translation missing: en.could not be found",
+                  detail: "could not be found",
                   source: {pointer: nil},
                   meta: {
                     relationship: {
                       attribute: "base",
-                      message: "translation missing: en.could not be found",
+                      message: "could not be found",
                       name: "classification",
                       type: "classifications",
                       id: "99999"

spec/request_validator_spec.rb

@@ -54,6 +54,23 @@ def self.name
       end
     end
 
+    context "when missing type" do
+      let(:payload) do
+        {
+          data: {
+            attributes: {
+              first_name: "Jane"
+            }
+          }
+        }
+      end
+
+      it "adds corresponding error" do
+        expect(validate).to eq(false)
+        expect(instance.errors).to be_added(:'data.type', :missing)
+      end
+    end
+
     context "when a single level resource payload" do
       let(:payload) do
         {