jsonapi-resources 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 233ad0db650881125288636b8fc022ccace40b01
-  data.tar.gz: 9c28dc89ef3f227398d6eecb9e4e274bcbd40d59
+  metadata.gz: 32e7bab3bce04e8ef68e0e58fd0274b128d7b68c
+  data.tar.gz: d12938d652c1ea0c692fea2c940354e673f75678
 SHA512:
-  metadata.gz: 57bca518364bab67494516f10166275905eeb115709113601eb96c691d6bbf1ee2d1db4aa0c17ec83093f746cc8d38f37d4f8f11e1b59b2a2ae68a35922585ca
-  data.tar.gz: 30c3a7125c2eccbcda03e0daa8adab71ac8542afa599d8787087ee9fa461aa1efaff9e95fc8544f6762b8405000d82cec1911adb6d3ec7e7a1e269f60bf387e2
+  metadata.gz: dd1e03599ab80a412cbe06e8d8d3231131a221f3406d82432c05d1b00c38b5002b3f1b30791c23328e613f12638f55ca35177439465ee1359dcb62f96a256057
+  data.tar.gz: 499fcf89189161652538b1716db928efe228b0db2e0d377012a0f98439463c1ef334cfc18b842a737f71e8c53aa9f2925932035cdbef3573726edcfb780d464b

data/README.md

@@ -340,7 +340,8 @@ end
 
 ##### Custom resource key validators
 
-If you need more control over the key, you can override the #verify_key method on your resource, or set a lambda that accepts key and context arguments in `config/initializers/jsonapi_resources.rb`:
+If you need more control over the key, you can override the #verify_key method on your resource, or set a lambda that
+accepts key and context arguments in `config/initializers/jsonapi_resources.rb`:
 
 ```ruby
 JSONAPI.configure do |config|
@@ -361,6 +362,38 @@ class AuthorResource < JSONAPI::Resource
 end
 ```
 
+#### Model Hints
+
+Resource instances are created from model records. The determination of the correct resource type is performed using a
+simple rule based on the model's name. The name is used to find a resource in the same module (as the originating 
+resource) that matches the name. This usually works quite well, however it can fail when model names do not match
+resource names. It can also fail when using namespaced models. In this case a `model_hint` can be created to map model
+names to resources. For example:
+
+```ruby
+class AuthorResource < JSONAPI::Resource
+  attribute :name
+  model_name 'Person'
+  model_hint model: Commenter, resource: :special_person
+
+  has_many :posts
+  has_many :commenters
+end
+```
+
+Note that when `model_name` is set a corresponding `model_hint` is also added. This can be skipped by using the
+`add_model_hint` option set to false. For example:
+
+```ruby
+class AuthorResource < JSONAPI::Resource
+  model_name 'Legacy::Person', add_model_hint: false
+end
+```
+
+Model hints inherit from parent resources, but are not global in scope. The `model_hint` method accepts `model` and
+`resource` named parameters. `model` takes an ActiveRecord class or class name (defaults to the model name), and 
+`resource` takes a resource type or a resource class (defaults to the current resource's type).
+
 #### Relationships
 
 Related resources need to be specified in the resource. These may be declared with the `relationship` or the `has_one`
@@ -509,11 +542,65 @@ end
 
 The default value is used as if it came from the request.
 
+##### Applying Filters
+
+You may customize how a filter behaves by supplying a callable to the `:apply` option. This callable will be used to
+apply that filter. The callable is passed the `records`, which is an `ActiveRecord::Relation`, the `value`, and an 
+`_options` hash. It is expected to return an `ActiveRecord::Relation`. 
+
+This example shows how you can implement different approaches for different filters.
+
+```ruby
+filter :visibility, apply: ->(records, value, _options) {
+  records.where('users.publicly_visible = ?', value == :public)
+}
+```
+
+If you omit the `apply` callable the filter will be applied as `records.where(filter => value)`.
+
+Note: It is also possible to override the `self.apply_filter` method, though this approach is now deprecated:
+
+```ruby
+def self.apply_filter(records, filter, value, options)
+  case filter
+    when :last_name, :first_name, :name
+      if value.is_a?(Array)
+        value.each do |val|
+          records = records.where(_model_class.arel_table[filter].matches(val))
+        end
+        return records
+      else
+        records.where(_model_class.arel_table[filter].matches(value))
+      end
+    else
+      return super(records, filter, value)
+  end
+end
+```
+
+##### Verifying Filters
+
+Because filters typically come straight from the request, it's prudent to verify their values. To do so, provide a 
+callable to the `verify` option. This callable will be passed the `value` and the `context`. Verify should return the
+verified value, which may be modified.
+
+```ruby
+  filter :ids,
+         verify: ->(values, context) {
+           verify_keys(values, context)
+           return values
+         },
+         apply: -> (records, value, _options) {
+           records.where('id IN (?)', value)
+         }
+```
+
 ##### Finders
 
 Basic finding by filters is supported by resources. This is implemented in the `find` and `find_by_key` finder methods.
 Currently this is implemented for `ActiveRecord` based resources. The finder methods rely on the `records` method to get
-an `Arel` relation. It is therefore possible to override `records` to affect the three find related methods.
+an `ActiveRecord::Relation` relation. It is therefore possible to override `records` to affect the three find related 
+methods.
 
 ###### Customizing base records for finder methods
 
@@ -572,7 +659,6 @@ class BaseResource < JSONAPI::Resource
 end
 ```
 
-
 ###### Raising Errors
 
 Inside the finder methods (like `records_for`) or inside of resource callbacks
@@ -635,6 +721,26 @@ def self.apply_filter(records, filter, value, options)
 end
 ```
 
+
+###### Applying Sorting
+
+You can override the `apply_sort` method to gain control over how the sorting is done. This may be useful in case you'd
+like to base the sorting on variables in your context.
+
+Example:
+
+```ruby
+def self.apply_sort(records, order_options, context = {})  
+  if order_options.has?(:trending)
+    records = records.order_by_trending_scope
+    order_options - [:trending]
+  end
+  
+  super(records, order_options, context)
+end
+```
+
+
 ###### Override finder methods
 
 Finally if you have more complex requirements for finding you can override the `find` and `find_by_key` methods on the

data/lib/jsonapi/acts_as_resource_controller.rb

@@ -64,12 +64,12 @@ module JSONAPI
         render_results(operation_results)
       end
 
+    rescue => e
+      handle_exceptions(e)
+    ensure
       if response.body.size > 0
         response.headers['Content-Type'] = JSONAPI::MEDIA_TYPE
       end
-
-    rescue => e
-      handle_exceptions(e)
     end
 
     # set the operations processor in the configuration or override this to use another operations processor
@@ -178,10 +178,10 @@ module JSONAPI
       case e
       when JSONAPI::Exceptions::Error
         render_errors(e.errors)
-      else # raise all other exceptions
-        # :nocov:
-        fail e
-        # :nocov:
+      else
+        internal_server_error = JSONAPI::Exceptions::InternalServerError.new(e)
+        Rails.logger.error { "Internal Server Error: #{e.message} #{e.backtrace.join("\n")}" }
+        render_errors(internal_server_error.errors)
       end
     end
 

data/lib/jsonapi/error.rb

@@ -1,6 +1,6 @@
 module JSONAPI
   class Error
-    attr_accessor :title, :detail, :id, :href, :code, :source, :links, :status
+    attr_accessor :title, :detail, :id, :href, :code, :source, :links, :status, :meta
 
     def initialize(options = {})
       @title          = options[:title]
@@ -16,6 +16,7 @@ module JSONAPI
       @links          = options[:links]
 
       @status         = Rack::Utils::SYMBOL_TO_STATUS_CODE[options[:status]].to_s
+      @meta           = options[:meta]
     end
   end
 

data/lib/jsonapi/exceptions.rb

@@ -10,10 +10,17 @@ module JSONAPI
       end
 
       def errors
+        unless Rails.env.production?
+          meta = Hash.new
+          meta[:exception] = exception.message
+          meta[:backtrace] = exception.backtrace
+        end
+
         [JSONAPI::Error.new(code: JSONAPI::INTERNAL_SERVER_ERROR,
                             status: :internal_server_error,
                             title: 'Internal Server Error',
-                            detail: 'Internal Server Error')]
+                            detail: 'Internal Server Error',
+                            meta: meta)]
       end
     end
 

data/lib/jsonapi/link_builder.rb

@@ -116,7 +116,7 @@ module JSONAPI
     def regular_primary_resources_path
       [
         formatted_module_path_from_class(primary_resource_klass),
-        route_formatter.format(primary_resource_klass._type.to_s),
+        format_route(primary_resource_klass._type.to_s),
       ].join
     end
 
@@ -127,7 +127,7 @@ module JSONAPI
     def regular_resource_path(source)
       [
         formatted_module_path_from_class(source.class),
-        route_formatter.format(source.class._type.to_s),
+        format_route(source.class._type.to_s),
         "/#{ source.id }",
       ].join
     end

data/lib/jsonapi/relationship.rb

@@ -1,14 +1,15 @@
 module JSONAPI
   class Relationship
     attr_reader :acts_as_set, :foreign_key, :type, :options, :name,
-                :class_name, :polymorphic, :always_include_linkage_data
+                :class_name, :polymorphic, :always_include_linkage_data,
+                :parent_resource
 
     def initialize(name, options = {})
       @name = name.to_s
       @options = options
       @acts_as_set = options.fetch(:acts_as_set, false) == true
       @foreign_key = options[:foreign_key] ? options[:foreign_key].to_sym : nil
-      @module_path = options[:module_path] || ''
+      @parent_resource = options[:parent_resource]
       @relation_name = options.fetch(:relation_name, @name)
       @polymorphic = options.fetch(:polymorphic, false) == true
       @always_include_linkage_data = options.fetch(:always_include_linkage_data, false) == true
@@ -21,7 +22,7 @@ module JSONAPI
     end
 
     def resource_klass
-      @resource_klass ||= Resource.resource_for(@module_path + @class_name)
+      @resource_klass = @parent_resource.resource_for(@class_name)
     end
 
     def relation_name(options)

data/lib/jsonapi/request.rb

@@ -463,7 +463,7 @@ module JSONAPI
 
       unless links_object[:id].nil?
         resource = self.resource_klass || Resource
-        relationship_resource = resource.resource_for(@resource_klass.module_path + unformat_key(links_object[:type]).to_s)
+        relationship_resource = resource.resource_for(unformat_key(links_object[:type]).to_s)
         relationship_id = relationship_resource.verify_key(links_object[:id], @context)
         if relationship.polymorphic?
           { id: relationship_id, type: unformat_key(links_object[:type].to_s) }
@@ -610,11 +610,6 @@ module JSONAPI
     def parse_single_replace_operation(data, keys, id_key_presence_check_required: true)
       fail JSONAPI::Exceptions::MissingKey.new if data[:id].nil?
 
-      type = data[:type]
-      if type.nil? || type != format_key(@resource_klass._type).to_s
-        fail JSONAPI::Exceptions::ParameterMissing.new(:type)
-      end
-
       key = data[:id]
       if id_key_presence_check_required && !keys.include?(key)
         fail JSONAPI::Exceptions::KeyNotIncludedInURL.new(key)

data/lib/jsonapi/resource.rb

@@ -4,8 +4,6 @@ module JSONAPI
   class Resource
     include Callbacks
 
-    @@resource_types = {}
-
     attr_reader :context
 
     define_jsonapi_resources_callbacks :create,
@@ -277,55 +275,61 @@ module JSONAPI
     end
 
     class << self
-      def inherited(base)
-        base.abstract(false)
-        base.immutable(false)
-        base._attributes = (_attributes || {}).dup
-        base._relationships = (_relationships || {}).dup
-        base._allowed_filters = (_allowed_filters || Set.new).dup
-
-        type = base.name.demodulize.sub(/Resource$/, '').underscore
-        base._type = type.pluralize.to_sym
-
-        base.attribute :id, format: :id
-
-        check_reserved_resource_name(base._type, base.name)
-      end
-
-      def resource_for(resource_path)
-        unless @@resource_types.key? resource_path
-          klass_name = "#{resource_path.to_s.underscore.singularize}_resource".camelize
-          klass = (klass_name.safe_constantize or
-            fail NameError,
-                 "JSONAPI: Could not find resource '#{resource_path}'. (Class #{klass_name} not found)")
-          normalized_path = resource_path.rpartition('/').first
-          normalized_model = klass._model_name.to_s.gsub(/\A::/, '')
-          @@resource_types[resource_path] = {
-            resource: klass,
-            path: normalized_path,
-            model: normalized_model,
-          }
+      def inherited(subclass)
+        subclass.abstract(false)
+        subclass.immutable(false)
+        subclass._attributes = (_attributes || {}).dup
+        subclass._model_hints = (_model_hints || {}).dup
+
+        subclass._relationships = {}
+        # Add the relationships from the base class to the subclass using the original options
+        if _relationships.is_a?(Hash)
+          _relationships.each_value do |relationship|
+            options = relationship.options.dup
+            options[:parent_resource] = subclass
+            subclass._add_relationship(relationship.class, relationship.name, options)
+          end
+        end
+
+        subclass._allowed_filters = (_allowed_filters || Set.new).dup
+
+        type = subclass.name.demodulize.sub(/Resource$/, '').underscore
+        subclass._type = type.pluralize.to_sym
+
+        subclass.attribute :id, format: :id
+
+        check_reserved_resource_name(subclass._type, subclass.name)
+      end
+
+      def resource_for(type)
+        type_with_module = type.include?('/') ? type : module_path + type
+
+        resource_name = _resource_name_from_type(type_with_module)
+        resource = resource_name.safe_constantize if resource_name
+        if resource.nil?
+          fail NameError, "JSONAPI: Could not find resource '#{type}'. (Class #{resource_name} not found)"
         end
-        @@resource_types[resource_path][:resource]
+        resource
       end
 
-      def resource_for_model_path(model, path)
-        normalized_model = model.class.to_s.gsub(/\A::/, '')
-        normalized_path = path.gsub(/\/\z/, '')
-        resource = @@resource_types.find { |_, h|
-          h[:path] == normalized_path && h[:model] == normalized_model
-        }
-        if resource
-          resource.last[:resource]
+      def resource_for_model(model)
+        resource_for(resource_type_for(model))
+      end
+
+      def _resource_name_from_type(type)
+        "#{type.to_s.underscore.singularize}_resource".camelize
+      end
+
+      def resource_type_for(model)
+        model_name = model.class.to_s.underscore
+        if _model_hints[model_name]
+          _model_hints[model_name]
         else
-          #:nocov:#
-          fail NameError,
-               "JSONAPI: Could not find resource for model '#{path}#{normalized_model}'"
-          #:nocov:#
+          model_name.rpartition('/').last
         end
       end
 
-      attr_accessor :_attributes, :_relationships, :_allowed_filters, :_type, :_paginator
+      attr_accessor :_attributes, :_relationships, :_allowed_filters, :_type, :_paginator, :_model_hints
 
       def create(context)
         new(create_model, context)
@@ -396,8 +400,17 @@ module JSONAPI
         _add_relationship(Relationship::ToMany, *attrs)
       end
 
-      def model_name(model)
+      def model_name(model, options = {})
         @_model_name = model.to_sym
+
+        model_hint(model: @_model_name, resource: self) unless options[:add_model_hint] == false
+      end
+
+      def model_hint(model: _model_name, resource: _type)
+        model_name = ((model.is_a?(Class)) && (model < ActiveRecord::Base)) ? model.name : model
+        resource_type = ((resource.is_a?(Class)) && (resource < JSONAPI::Resource)) ? resource._type : resource.to_s
+
+        _model_hints[model_name.to_s.gsub('::', '/').underscore] = resource_type.to_s
       end
 
       def filters(*attrs)
@@ -486,7 +499,7 @@ module JSONAPI
         records
       end
 
-      def apply_sort(records, order_options)
+      def apply_sort(records, order_options, _context = {})
         if order_options.any?
           records.order(order_options)
         else
@@ -494,8 +507,14 @@ module JSONAPI
         end
       end
 
-      def apply_filter(records, filter, value, _options = {})
-        records.where(filter => value)
+      def apply_filter(records, filter, value, options = {})
+        strategy = _allowed_filters.fetch(filter.to_sym, Hash.new)[:apply]
+
+        if strategy
+          strategy.call(records, value, options)
+        else
+          records.where(filter => value)
+        end
       end
 
       def apply_filters(records, filters, options = {})
@@ -528,8 +547,8 @@ module JSONAPI
         apply_includes(records, options)
       end
 
-      def sort_records(records, order_options)
-        apply_sort(records, order_options)
+      def sort_records(records, order_options, context = {})
+        apply_sort(records, order_options, context)
       end
 
       def find_count(filters, options = {})
@@ -544,13 +563,13 @@ module JSONAPI
 
         sort_criteria = options.fetch(:sort_criteria) { [] }
         order_options = construct_order_options(sort_criteria)
-        records = sort_records(records, order_options)
+        records = sort_records(records, order_options, context)
 
         records = apply_pagination(records, options[:paginator], order_options)
 
         resources = []
         records.each do |model|
-          resources.push resource_for_model_path(model, self.module_path).new(model, context)
+          resources.push self.resource_for_model(model).new(model, context)
         end
 
         resources
@@ -562,7 +581,7 @@ module JSONAPI
         records = apply_includes(records, options)
         model = records.where({_primary_key => key}).first
         fail JSONAPI::Exceptions::RecordNotFound.new(key) if model.nil?
-        resource_for_model_path(model, self.module_path).new(model, context)
+        self.resource_for_model(model).new(model, context)
       end
 
       # Override this method if you want to customize the relation for
@@ -588,10 +607,16 @@ module JSONAPI
         filter_values = []
         filter_values += CSV.parse_line(raw) unless raw.nil? || raw.empty?
 
-        if is_filter_relationship?(filter)
-          verify_relationship_filter(filter, filter_values, context)
+        strategy = _allowed_filters.fetch(filter, Hash.new)[:verify]
+
+        if strategy
+          [filter, strategy.call(filter_values, context)]
         else
-          verify_custom_filter(filter, filter_values, context)
+          if is_filter_relationship?(filter)
+            verify_relationship_filter(filter, filter_values, context)
+          else
+            verify_custom_filter(filter, filter_values, context)
+          end
         end
       end
 
@@ -638,12 +663,13 @@ module JSONAPI
         end
       end
 
-      # override to allow for custom filters
+      # Either add a custom :verify labmda or override verify_custom_filter to allow for custom filters
       def verify_custom_filter(filter, value, _context = nil)
         [filter, value]
       end
 
-      # override to allow for custom relationship logic, such as uuids, multiple keys or permission checks on keys
+      # Either add a custom :verify labmda or override verify_relationship_filter to allow for custom
+      # relationship logic, such as uuids, multiple keys or permission checks on keys
       def verify_relationship_filter(filter, raw, _context = nil)
         [filter, raw]
       end
@@ -663,7 +689,7 @@ module JSONAPI
       end
 
       def _model_name
-        @_model_name ||= name.demodulize.sub(/Resource$/, '')
+        _abstract ? '' : @_model_name ||= name.demodulize.sub(/Resource$/, '')
       end
 
       def _primary_key
@@ -720,7 +746,11 @@ module JSONAPI
       end
 
       def module_path
-        name =~ /::[^:]+\Z/ ? ($`.freeze.gsub('::', '/') + '/').underscore : ''
+        if name == 'JSONAPI::Resource'
+          ''
+        else
+          name =~ /::[^:]+\Z/ ? ($`.freeze.gsub('::', '/') + '/').underscore : ''
+        end
       end
 
       def construct_order_options(sort_params)
@@ -732,49 +762,28 @@ module JSONAPI
         end
       end
 
-      private
-
-      def check_reserved_resource_name(type, name)
-        if [:ids, :types, :hrefs, :links].include?(type)
-          warn "[NAME COLLISION] `#{name}` is a reserved resource name."
-          return
-        end
-      end
-
-      def check_reserved_attribute_name(name)
-        # Allow :id since it can be used to specify the format. Since it is a method on the base Resource
-        # an attribute method won't be created for it.
-        if [:type].include?(name.to_sym)
-          warn "[NAME COLLISION] `#{name}` is a reserved key in #{@@resource_types[_type]}."
-        end
-      end
-
-      def check_reserved_relationship_name(name)
-        if [:id, :ids, :type, :types].include?(name.to_sym)
-          warn "[NAME COLLISION] `#{name}` is a reserved relationship name in #{@@resource_types[_type]}."
-        end
-      end
-
       def _add_relationship(klass, *attrs)
         options = attrs.extract_options!
-        options[:module_path] = module_path
+        options[:parent_resource] = self
 
         attrs.each do |attr|
-          check_reserved_relationship_name(attr)
+          relationship_name = attr.to_sym
+
+          check_reserved_relationship_name(relationship_name)
 
           # Initialize from an ActiveRecord model's properties
           if _model_class && _model_class.ancestors.collect{|ancestor| ancestor.name}.include?('ActiveRecord::Base')
-            model_association = _model_class.reflect_on_association(attr)
+            model_association = _model_class.reflect_on_association(relationship_name)
             if model_association
               options[:class_name] ||= model_association.class_name
             end
           end
 
-          @_relationships[attr] = relationship = klass.new(attr, options)
+          @_relationships[relationship_name] = relationship = klass.new(relationship_name, options)
 
           associated_records_method_name = case relationship
-                                           when JSONAPI::Relationship::ToOne then "record_for_#{attr}"
-                                           when JSONAPI::Relationship::ToMany then "records_for_#{attr}"
+                                           when JSONAPI::Relationship::ToOne then "record_for_#{relationship_name}"
+                                           when JSONAPI::Relationship::ToMany then "records_for_#{relationship_name}"
                                            end
 
           foreign_key = relationship.foreign_key
@@ -784,6 +793,7 @@ module JSONAPI
           end unless method_defined?("#{foreign_key}=")
 
           define_method associated_records_method_name do
+            relationship = self.class._relationships[relationship_name]
             relation_name = relationship.relation_name(context: @context)
             records_for(relation_name)
           end unless method_defined?(associated_records_method_name)
@@ -794,10 +804,12 @@ module JSONAPI
                 @model.method(foreign_key).call
               end unless method_defined?(foreign_key)
 
-              define_method attr do |options = {}|
+              define_method relationship_name do |options = {}|
+                relationship = self.class._relationships[relationship_name]
+
                 if relationship.polymorphic?
                   associated_model = public_send(associated_records_method_name)
-                  resource_klass = self.class.resource_for_model_path(associated_model, self.class.module_path) if associated_model
+                  resource_klass = self.class.resource_for_model(associated_model) if associated_model
                   return resource_klass.new(associated_model, @context) if resource_klass
                 else
                   resource_klass = relationship.resource_klass
@@ -806,21 +818,25 @@ module JSONAPI
                     return associated_model ? resource_klass.new(associated_model, @context) : nil
                   end
                 end
-              end unless method_defined?(attr)
+              end unless method_defined?(relationship_name)
             else
               define_method foreign_key do
+                relationship = self.class._relationships[relationship_name]
+
                 record = public_send(associated_records_method_name)
                 return nil if record.nil?
                 record.public_send(relationship.resource_klass._primary_key)
               end unless method_defined?(foreign_key)
 
-              define_method attr do |options = {}|
+              define_method relationship_name do |options = {}|
+                relationship = self.class._relationships[relationship_name]
+
                 resource_klass = relationship.resource_klass
                 if resource_klass
                   associated_model = public_send(associated_records_method_name)
                   return associated_model ? resource_klass.new(associated_model, @context) : nil
                 end
-              end unless method_defined?(attr)
+              end unless method_defined?(relationship_name)
             end
           elsif relationship.is_a?(JSONAPI::Relationship::ToMany)
             define_method foreign_key do
@@ -829,7 +845,10 @@ module JSONAPI
                 record.public_send(relationship.resource_klass._primary_key)
               end
             end unless method_defined?(foreign_key)
-            define_method attr do |options = {}|
+
+            define_method relationship_name do |options = {}|
+              relationship = self.class._relationships[relationship_name]
+
               resource_klass = relationship.resource_klass
               records = public_send(associated_records_method_name)
 
@@ -841,7 +860,7 @@ module JSONAPI
               sort_criteria =  options.fetch(:sort_criteria, {})
               unless sort_criteria.nil? || sort_criteria.empty?
                 order_options = relationship.resource_klass.construct_order_options(sort_criteria)
-                records = resource_klass.apply_sort(records, order_options)
+                records = resource_klass.apply_sort(records, order_options, @context)
               end
 
               paginator = options[:paginator]
@@ -850,13 +869,38 @@ module JSONAPI
               end
 
               return records.collect do |record|
-                resource_klass = self.class.resource_for_model_path(record, self.class.module_path)
+                if relationship.polymorphic?
+                  resource_klass = self.class.resource_for_model(record)
+                end
                 resource_klass.new(record, @context)
               end
-            end unless method_defined?(attr)
+            end unless method_defined?(relationship_name)
           end
         end
       end
+
+      private
+
+      def check_reserved_resource_name(type, name)
+        if [:ids, :types, :hrefs, :links].include?(type)
+          warn "[NAME COLLISION] `#{name}` is a reserved resource name."
+          return
+        end
+      end
+
+      def check_reserved_attribute_name(name)
+        # Allow :id since it can be used to specify the format. Since it is a method on the base Resource
+        # an attribute method won't be created for it.
+        if [:type].include?(name.to_sym)
+          warn "[NAME COLLISION] `#{name}` is a reserved key in #{_resource_name_from_type(_type)}."
+        end
+      end
+
+      def check_reserved_relationship_name(name)
+        if [:id, :ids, :type, :types].include?(name.to_sym)
+          warn "[NAME COLLISION] `#{name}` is a reserved relationship name in #{_resource_name_from_type(_type)}."
+        end
+      end
     end
   end
 end