jsonapi_compliable 0.11.34 → 1.0.alpha.2

data/lib/jsonapi_compliable/context.rb

@@ -0,0 +1,16 @@
+module JsonapiCompliable
+  module Context
+    extend ActiveSupport::Concern
+
+    module Overrides
+      def sideload_whitelist=(val)
+        super(JSONAPI::IncludeDirective.new(val).to_hash)
+      end
+    end
+
+    included do
+      class_attribute :sideload_whitelist
+      class << self;prepend Overrides;end
+    end
+  end
+end

data/lib/jsonapi_compliable/deserializer.rb

@@ -45,26 +45,18 @@
 #
 #   { type: 'authors', method: :create, temp_id: 'abc123' }
 class JsonapiCompliable::Deserializer
-  # @param payload [Hash] The incoming payload with symbolized keys
-  # @param env [Hash] the Rack env (e.g. +request.env+).
-  def initialize(payload, env)
-    @payload = payload || {}
+  def initialize(payload)
+    @payload = payload
     @payload = @payload[:_jsonapi] if @payload.has_key?(:_jsonapi)
-    @env = env
-    validate_content_type
   end
 
-  # checks Content-Type header and prints a warning if it doesn't seem correct
-  def validate_content_type
-    content_type = @env['CONTENT_TYPE'] || ""
-    if !(content_type.include?("application/json") || content_type.include?("application/vnd.api+json"))
-      print("WARNING - JSONAPI Compliable :: Content-Type header appears to be set to an invalid value: #{content_type}\n")
-    end
+  def params
+    @payload
   end
 
   # @return [Hash] the raw :data value of the payload
   def data
-    @payload[:data] || {}
+    @payload[:data]
   end
 
   # @return [String] the raw :id value of the payload
@@ -92,11 +84,11 @@ class JsonapiCompliable::Deserializer
   # +temp_id+: the +temp-id+, if specified
   #
   # @return [Hash]
-  def meta
+  def meta(action: :update)
     {
       type: data[:type],
       temp_id: data[:'temp-id'],
-      method: method
+      method: action
     }
   end
 
@@ -105,20 +97,11 @@ class JsonapiCompliable::Deserializer
     @relationships ||= process_relationships(raw_relationships)
   end
 
-  # Parses the +relationships+ recursively and builds an all-hash
-  # include directive like
-  #
-  #   { posts: { comments: {} } }
-  #
-  # Relationships that have been marked for destruction will NOT
-  # be part of the include directive.
-  #
-  # @return [Hash] the include directive
-  def include_directive(memo = {}, relationship_node = nil)
+  def include_hash(memo = {}, relationship_node = nil)
     relationship_node ||= relationships
 
     relationship_node.each_pair do |name, relationship_payload|
-      merge_include_directive(memo, name, relationship_payload)
+      merge_include_hash(memo, name, relationship_payload)
     end
 
     memo
@@ -126,12 +109,12 @@ class JsonapiCompliable::Deserializer
 
   private
 
-  def merge_include_directive(memo, name, relationship_payload)
+  def merge_include_hash(memo, name, relationship_payload)
     arrayified = [relationship_payload].flatten
     return if arrayified.all? { |rp| removed?(rp) }
 
     memo[name] ||= {}
-    deep_merge!(memo[name], sub_directives(memo[name], arrayified))
+    deep_merge!(memo[name], nested_include_hashes(memo[name], arrayified))
     memo
   end
 
@@ -139,24 +122,16 @@ class JsonapiCompliable::Deserializer
     @payload[:included] || []
   end
 
-  def method
-    case @env['REQUEST_METHOD']
-      when 'POST' then :create
-      when 'PUT', 'PATCH' then :update
-      when 'DELETE' then :destroy
-    end
-  end
-
   def removed?(relationship_payload)
     method = relationship_payload[:meta][:method]
     [:disassociate, :destroy].include?(method)
   end
 
-  def sub_directives(memo, relationship_payloads)
+  def nested_include_hashes(memo, relationship_payloads)
     {}.tap do |subs|
       relationship_payloads.each do |rp|
-        sub_directive = include_directive(memo, rp[:relationships])
-        deep_merge!(subs, sub_directive)
+        nested = include_hash(memo, rp[:relationships])
+        deep_merge!(subs, nested)
       end
     end
   end

data/lib/jsonapi_compliable/errors.rb

@@ -1,8 +1,98 @@
 module JsonapiCompliable
   module Errors
-    class BadFilter < StandardError; end
+    class Base < StandardError;end
 
-    class ValidationError < StandardError
+    class AdapterNotImplemented < Base
+      def initialize(adapter, attribute, method)
+        @adapter = adapter
+        @attribute = attribute
+        @method = method
+      end
+
+      def message
+        <<-MSG
+The adapter #{@adapter.class} does not implement method '#{@method}', which was requested for attribute '#{@attribute}'. Add this method to your adapter to support this filter operator.
+        MSG
+      end
+    end
+
+    class AttributeError < Base
+      attr_reader :resource,
+        :name,
+        :flag,
+        :exists,
+        :request,
+        :guard
+
+      def initialize(resource, name, flag, **opts)
+        @resource = resource
+        @name = name
+        @flag = flag
+        @exists = opts[:exists] || false
+        @request = opts[:request] || false
+        @guard = opts[:guard]
+      end
+
+      def action
+        if @request
+          {
+            sortable: 'sort on',
+            filterable: 'filter on',
+            readable: 'read',
+            writable: 'write'
+          }[@flag]
+        else
+          {
+            sortable: 'add sort',
+            filterable: 'add filter',
+            readable: 'read',
+            writable: 'write'
+          }[@flag]
+        end
+      end
+
+      def resource_name
+        name = if @resource.is_a?(JsonapiCompliable::Resource)
+          @resource.class.name
+        else
+          @resource.name
+        end
+        name || 'AnonymousResourceClass'
+      end
+
+      def message
+        msg = "#{resource_name}: Tried to #{action} attribute #{@name.inspect}"
+        if @exists
+          if @guard
+            msg << ", but the guard #{@guard.inspect} did not pass."
+          else
+            msg << ", but the attribute was marked #{@flag.inspect} => false."
+          end
+        else
+          msg << ", but could not find an attribute with that name."
+        end
+        msg
+      end
+    end
+
+    class PolymorphicChildNotFound < Base
+      def initialize(resource_class, model)
+        @resource_class = resource_class
+        @model = model
+      end
+
+      def message
+        <<-MSG
+#{@resource_class}: Tried to find subclass with model #{@model.class}, but nothing found!
+
+Make sure all your child classes are assigned and associated to the right models:
+
+self.polymorphic = ['Subclass1Resource', 'Subclass2Resource']
+        MSG
+      end
+    end
+
+    class ValidationError < Base
       attr_reader :validation_response
 
       def initialize(validation_response)
@@ -10,41 +100,153 @@ module JsonapiCompliable
       end
     end
 
-    class MissingSerializer < StandardError
-      def initialize(class_name, serializer_name)
-        @class_name = class_name
-        @serializer_name = serializer_name
+    class ImplicitFilterTypeMissing < Base
+      def initialize(resource_class, name)
+        @resource_class = resource_class
+        @name = name
       end
 
       def message
         <<-MSG
-Could not find serializer for class '#{@class_name}'!
+Tried to add filter-only attribute #{@name.inspect}, but type was missing!
 
-Looked for '#{@serializer_name}' but doesn't appear to exist.
+If you are adding a filter that does not have a corresponding attribute, you must pass a type:
 
-Use a custom Inferrer if you'd like different lookup logic.
+filter :name, :string do <--- like this
+  # ... code ...
+end
         MSG
       end
     end
 
-    class MissingSerializer < StandardError
-      def initialize(class_name, serializer_name)
-        @class_name = class_name
-        @serializer_name = serializer_name
+    class ImplicitSortTypeMissing < Base
+      def initialize(resource_class, name)
+        @resource_class = resource_class
+        @name = name
       end
 
       def message
         <<-MSG
-Could not find serializer for class '#{@class_name}'!
+Tried to add sort-only attribute #{@name.inspect}, but type was missing!
+
+If you are adding a sort that does not have a corresponding attribute, you must pass a type:
+
+sort :name, :string do <--- like this
+  # ... code ...
+end
+        MSG
+      end
+    end
+
+    class TypecastFailed < Base
+      def initialize(resource, name, value, error)
+        @resource = resource
+        @name = name
+        @value = value
+        @error = error
+      end
+
+      def message
+        <<-MSG
+#{@resource.class}: Failed typecasting #{@name.inspect}! Given #{@value.inspect} but the following error was raised:
+
+#{@error.message}
+
+#{@error.backtrace.join("\n")}
+        MSG
+      end
+    end
+
+    class ModelNotFound < Base
+      def initialize(resource_class)
+        @resource_class = resource_class
+      end
+
+      def message
+        <<-MSG
+Could not find model for Resource '#{@resource_class}'
+
+Manually set model (self.model = MyModel) if it does not match name of the Resource.
+        MSG
+      end
+    end
+
+    class TypeNotFound < Base
+      def initialize(resource, attribute, type)
+        @resource = resource
+        @attribute = attribute
+        @type = type
+      end
+
+      def message
+        <<-MSG
+Could not find type #{@type.inspect}! This was specified on attribute #{@attribute.inspect} within resource #{@resource.name}
+
+Valid types are: #{JsonapiCompliable::Types.map.keys.inspect}
+        MSG
+      end
+    end
+
+    class PolymorphicChildNotFound < Base
+      def initialize(sideload, name)
+        @sideload = sideload
+        @name = name
+      end
+
+      def message
+        <<-MSG
+#{@sideload.parent_resource}: Found record with #{@sideload.grouper.column_name.inspect} == #{@name.inspect}, which is not registered!
+
+Register the behavior of different types like so:
+
+polymorphic_belongs_to #{@sideload.name.inspect} do
+  group_by(#{@sideload.grouper.column_name.inspect}) do
+    on(#{@name.to_sym.inspect}) <---- this is what's missing
+    on(:foo).belongs_to :foo, resource: FooResource (long-hand example)
+  end
+end
+        MSG
+      end
+    end
+
+    class ResourceNotFound < Base
+      def initialize(resource, sideload_name)
+        @resource = resource
+        @sideload_name = sideload_name
+      end
+
+      def message
+        <<-MSG
+Could not find resource class for sideload '#{@sideload_name}' on Resource '#{@resource.class.name}'!
+
+If this follows a non-standard naming convention, use the :resource option to pass it directly:
+
+has_many :comments, resource: SpecialCommentResource
+        MSG
+      end
+    end
+
+    class UnsupportedPagination < Base
+      def message
+        <<-MSG
+It looks like you are requesting pagination of a sideload, but there are > 1 parents.
+
+This is not supported. In other words, you can do
+
+/employees/1?include=positions&page[positions][size]=2
+
+But not
+
+/employees?include=positions&page[positions][size]=2
 
-Looked for '#{@serializer_name}' but doesn't appear to exist.
+This is a limitation of most datastores; the same issue exists in ActiveRecord.
 
-Use a custom Inferrer if you'd like different lookup logic.
+Consider using a named relationship instead, e.g. 'has_one :top_comment'
         MSG
       end
     end
 
-    class UnsupportedPageSize < StandardError
+    class UnsupportedPageSize < Base
       def initialize(size, max)
         @size, @max = size, max
       end
@@ -54,7 +256,7 @@ Use a custom Inferrer if you'd like different lookup logic.
       end
     end
 
-    class InvalidInclude < StandardError
+    class InvalidInclude < Base
       def initialize(relationship, parent_resource)
         @relationship = relationship
         @parent_resource = parent_resource
@@ -65,7 +267,7 @@ Use a custom Inferrer if you'd like different lookup logic.
       end
     end
 
-    class StatNotFound < StandardError
+    class StatNotFound < Base
       def initialize(attribute, calculation)
         @attribute = attribute
         @calculation = calculation
@@ -86,19 +288,20 @@ Use a custom Inferrer if you'd like different lookup logic.
       end
     end
 
-    class RecordNotFound < StandardError
+    class RecordNotFound < Base
     end
 
-    class RequiredFilter < StandardError
-      def initialize(attributes)
+    class RequiredFilter < Base
+      def initialize(resource, attributes)
+        @resource = resource
         @attributes = Array(attributes)
       end
 
       def message
         if @attributes.length > 1
-          "The required filters \"#{@attributes.join(', ')}\" were not provided"
+          "The required filters \"#{@attributes.join(', ')}\" on resource #{@resource.class} were not provided"
         else
-          "The required filter \"#{@attributes[0]}\" was not provided"
+          "The required filter \"#{@attributes[0]}\" on resource #{@resource.class} was not provided"
         end
       end
     end

data/lib/jsonapi_compliable/extensions/extra_attribute.rb

@@ -46,7 +46,9 @@ module JsonapiCompliable
               next false unless instance_eval(&options[:if])
             end
 
-            @extra_fields[@_type] && @extra_fields[@_type].include?(name)
+            @extra_fields &&
+              @extra_fields[@_type] &&
+              @extra_fields[@_type].include?(name)
           }
 
           attribute name, if: allow_field, &blk