jsonapi-resources 0.9.0 → 0.9.12

data/lib/jsonapi/request_parser.rb

@@ -52,6 +52,7 @@ module JSONAPI
     end
 
     def setup_get_related_resource_action(params)
+      resolve_singleton_id(params)
       initialize_source(params)
       parse_fields(params[:fields])
       parse_include_directives(params[:include])
@@ -63,6 +64,7 @@ module JSONAPI
     end
 
     def setup_get_related_resources_action(params)
+      resolve_singleton_id(params)
       initialize_source(params)
       parse_fields(params[:fields])
       parse_include_directives(params[:include])
@@ -74,13 +76,17 @@ module JSONAPI
     end
 
     def setup_show_action(params)
+      resolve_singleton_id(params)
       parse_fields(params[:fields])
       parse_include_directives(params[:include])
+      parse_filters(params[:filter])
+
       @id = params[:id]
       add_show_operation
     end
 
     def setup_show_relationship_action(params)
+      resolve_singleton_id(params)
       add_show_relationship_operation(params[:relationship], params.require(@resource_klass._as_parent_key))
     end
 
@@ -91,24 +97,29 @@ module JSONAPI
     end
 
     def setup_create_relationship_action(params)
+      resolve_singleton_id(params)
       parse_modify_relationship_action(params, :add)
     end
 
     def setup_update_relationship_action(params)
+      resolve_singleton_id(params)
       parse_modify_relationship_action(params, :update)
     end
 
     def setup_update_action(params)
+      resolve_singleton_id(params)
       parse_fields(params[:fields])
       parse_include_directives(params[:include])
       parse_replace_operation(params.require(:data), params[:id])
     end
 
     def setup_destroy_action(params)
+      resolve_singleton_id(params)
       parse_remove_operation(params)
     end
 
     def setup_destroy_relationship_action(params)
+      resolve_singleton_id(params)
       parse_modify_relationship_action(params, :remove)
     end
 
@@ -170,13 +181,11 @@ module JSONAPI
           end
           type_resource = Resource.resource_for(@resource_klass.module_path + underscored_type.to_s)
         rescue NameError
-          @errors.concat(JSONAPI::Exceptions::InvalidResource.new(type).errors)
-        rescue JSONAPI::Exceptions::InvalidResource => e
-          @errors.concat(e.errors)
+          fail JSONAPI::Exceptions::InvalidResource.new(type)
         end
 
         if type_resource.nil?
-          @errors.concat(JSONAPI::Exceptions::InvalidResource.new(type).errors)
+          fail JSONAPI::Exceptions::InvalidResource.new(type)
         else
           unless values.nil?
             valid_fields = type_resource.fields.collect { |key| format_key(key) }
@@ -184,11 +193,11 @@ module JSONAPI
               if valid_fields.include?(field)
                 extracted_fields[type].push unformat_key(field)
               else
-                @errors.concat(JSONAPI::Exceptions::InvalidField.new(type, field).errors)
+                fail JSONAPI::Exceptions::InvalidField.new(type, field)
               end
             end
           else
-            @errors.concat(JSONAPI::Exceptions::InvalidField.new(type, 'nil').errors)
+            fail JSONAPI::Exceptions::InvalidField.new(type, 'nil')
           end
         end
       end
@@ -205,8 +214,7 @@ module JSONAPI
           check_include(Resource.resource_for(resource_klass.module_path + relationship.class_name.to_s.underscore), include_parts.last.partition('.'))
         end
       else
-        @errors.concat(JSONAPI::Exceptions::InvalidInclude.new(format_key(resource_klass._type),
-                                                               include_parts.first).errors)
+        fail JSONAPI::Exceptions::InvalidInclude.new(format_key(resource_klass._type), include_parts.first)
       end
     end
 
@@ -214,31 +222,36 @@ module JSONAPI
       return unless raw_include
 
       unless JSONAPI.configuration.allow_include
-        fail JSONAPI::Exceptions::ParametersNotAllowed.new([:include])
+        fail JSONAPI::Exceptions::ParameterNotAllowed.new(:include)
       end
 
       included_resources = []
       begin
-        included_resources += CSV.parse_line(raw_include)
+        included_resources += Array(CSV.parse_line(raw_include))
       rescue CSV::MalformedCSVError
         fail JSONAPI::Exceptions::InvalidInclude.new(format_key(@resource_klass._type), raw_include)
       end
 
       return if included_resources.empty?
 
-      result = included_resources.compact.map do |included_resource|
-        check_include(@resource_klass, included_resource.partition('.'))
-        unformat_key(included_resource).to_s
-      end
+      begin
+        result = included_resources.compact.map do |included_resource|
+          check_include(@resource_klass, included_resource.partition('.'))
+          unformat_key(included_resource).to_s
+        end
 
-      @include_directives = JSONAPI::IncludeDirectives.new(@resource_klass, result)
+        @include_directives = JSONAPI::IncludeDirectives.new(@resource_klass, result)
+      rescue JSONAPI::Exceptions::InvalidInclude => e
+        @errors.concat(e.errors)
+        @include_directives = JSONAPI::IncludeDirectives.new(@resource_klass, [])
+      end
     end
 
     def parse_filters(filters)
       return unless filters
 
       unless JSONAPI.configuration.allow_filter
-        fail JSONAPI::Exceptions::ParametersNotAllowed.new([:filter])
+        fail JSONAPI::Exceptions::ParameterNotAllowed.new(:filter)
       end
 
       unless filters.class.method_defined?(:each)
@@ -247,12 +260,41 @@ module JSONAPI
       end
 
       filters.each do |key, value|
-        filter = unformat_key(key)
-        if @resource_klass._allowed_filter?(filter)
-          @filters[filter] = value
+
+        unformatted_key = unformat_key(key)
+        if resource_klass._allowed_filter?(unformatted_key)
+          @filters[unformatted_key] = value
+        elsif unformatted_key.to_s.include?('.')
+          parse_relationship_filter(unformatted_key, value)
         else
-          @errors.concat(JSONAPI::Exceptions::FilterNotAllowed.new(filter).errors)
+          return @errors.concat(Exceptions::FilterNotAllowed.new(unformatted_key).errors)
+        end
+      end
+    end
+
+    def parse_relationship_filter(key, value)
+      included_resource_name, filter_method = key.to_s.split('.')
+      filter_method = filter_method.to_sym if filter_method.present?
+
+      if included_resource_name
+        relationship = resource_klass._relationship(included_resource_name || '')
+
+        unless relationship
+          return @errors.concat(Exceptions::FilterNotAllowed.new(filter_method).errors)
+        end
+
+        unless  relationship.resource_klass._allowed_filter?(filter_method)
+          return @errors.concat(Exceptions::FilterNotAllowed.new(filter_method).errors)
+        end
+
+        unless @include_directives.try(:include_config, relationship.name.to_sym).present?
+          return @errors.concat(Exceptions::FilterNotAllowed.new(filter_method).errors)
         end
+
+        verified_filter = relationship.resource_klass.verify_filters({ filter_method => value }, @context)
+        @include_directives.merge_filter(relationship.name, verified_filter)
+      else
+        return @errors.concat(Exceptions::FilterNotAllowed.new(filter_method).errors)
       end
     end
 
@@ -267,12 +309,12 @@ module JSONAPI
       return unless sort_criteria.present?
 
       unless JSONAPI.configuration.allow_sort
-        fail JSONAPI::Exceptions::ParametersNotAllowed.new([:sort])
+        fail JSONAPI::Exceptions::ParameterNotAllowed.new(:sort)
       end
 
       sorts = []
       begin
-        raw = URI.unescape(sort_criteria)
+        raw = URI::DEFAULT_PARSER.unescape(sort_criteria)
         sorts += CSV.parse_line(raw)
       rescue CSV::MalformedCSVError
         fail JSONAPI::Exceptions::InvalidSortCriteria.new(format_key(@resource_klass._type), raw)
@@ -296,9 +338,8 @@ module JSONAPI
       sort_field = sort_criteria[:field]
       sortable_fields = resource_klass.sortable_fields(context)
 
-      unless sortable_fields.include? sort_field.to_sym
-        @errors.concat(JSONAPI::Exceptions::InvalidSortCriteria
-                         .new(format_key(resource_klass._type), sort_field).errors)
+      unless sortable_fields.include?sort_field.to_sym
+        fail JSONAPI::Exceptions::InvalidSortCriteria.new(format_key(resource_klass._type), sort_field)
       end
     end
 
@@ -352,7 +393,7 @@ module JSONAPI
         relationship_type: relationship_type,
         source_klass: @source_klass,
         source_id: @source_id,
-        filters: @source_klass.verify_filters(@filters, @context),
+        filters: @filters,
         sort_criteria: @sort_criteria,
         paginator: @paginator,
         fields: @fields,
@@ -473,7 +514,7 @@ module JSONAPI
 
       unless links_object[:id].nil?
         resource = self.resource_klass || Resource
-        relationship_resource = resource.resource_for(unformat_key(links_object[:type]).to_s)
+        relationship_resource = resource.resource_for(unformat_key(relationship.options[:class_name] || 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) }
@@ -496,20 +537,40 @@ module JSONAPI
 
       links_object = parse_to_many_links_object(linkage)
 
-      # Since we do not yet support polymorphic to_many relationships we will raise an error if the type does not match the
-      # relationship's type.
-      # ToDo: Support Polymorphic relationships
-
       if links_object.length == 0
         add_result.call([])
       else
-        if links_object.length > 1 || !links_object.has_key?(unformat_key(relationship.type).to_s)
-          fail JSONAPI::Exceptions::TypeMismatch.new(links_object[:type])
-        end
+        if relationship.polymorphic?
+          polymorphic_results = []
+
+          links_object.each_pair do |type, keys|
+            resource = self.resource_klass || Resource
+            type_name = unformat_key(type).to_s
+
+            relationship_resource_klass = resource.resource_for(relationship.class_name)
+            relationship_klass = relationship_resource_klass._model_class
+
+            linkage_object_resource_klass = resource.resource_for(type_name)
+            linkage_object_klass = linkage_object_resource_klass._model_class
+
+            unless linkage_object_klass == relationship_klass || linkage_object_klass.in?(relationship_klass.subclasses)
+              fail JSONAPI::Exceptions::TypeMismatch.new(type_name)
+            end
 
-        links_object.each_pair do |type, keys|
-          relationship_resource = Resource.resource_for(@resource_klass.module_path + unformat_key(type).to_s)
-          add_result.call relationship_resource.verify_keys(keys, @context)
+            relationship_ids = relationship_resource_klass.verify_keys(keys, @context)
+             polymorphic_results << { type: type, ids: relationship_ids }
+          end
+
+          add_result.call polymorphic_results
+        else
+          relationship_type = unformat_key(relationship.type).to_s
+
+          if links_object.length > 1 || !links_object.has_key?(relationship_type)
+            fail JSONAPI::Exceptions::TypeMismatch.new(links_object[:type])
+          end
+
+          relationship_resource = Resource.resource_for(@resource_klass.module_path + relationship_type)
+          add_result.call relationship_resource.verify_keys(links_object[relationship_type], @context)
         end
       end
     end
@@ -528,8 +589,10 @@ module JSONAPI
         when 'relationships'
           value.keys.each do |links_key|
             unless formatted_allowed_fields.include?(links_key.to_sym)
-              params_not_allowed.push(links_key)
-              unless JSONAPI.configuration.raise_if_parameters_not_allowed
+              if JSONAPI.configuration.raise_if_parameters_not_allowed
+                fail JSONAPI::Exceptions::ParameterNotAllowed.new(links_key)
+              else
+                params_not_allowed.push(links_key)
                 value.delete links_key
               end
             end
@@ -537,8 +600,10 @@ module JSONAPI
         when 'attributes'
           value.each do |attr_key, attr_value|
             unless formatted_allowed_fields.include?(attr_key.to_sym)
-              params_not_allowed.push(attr_key)
-              unless JSONAPI.configuration.raise_if_parameters_not_allowed
+              if JSONAPI.configuration.raise_if_parameters_not_allowed
+                fail JSONAPI::Exceptions::ParameterNotAllowed.new(attr_key)
+              else
+                params_not_allowed.push(attr_key)
                 value.delete attr_key
               end
             end
@@ -546,27 +611,30 @@ module JSONAPI
         when 'type'
         when 'id'
           unless formatted_allowed_fields.include?(:id)
-            params_not_allowed.push(:id)
-            unless JSONAPI.configuration.raise_if_parameters_not_allowed
+            if JSONAPI.configuration.raise_if_parameters_not_allowed
+              fail JSONAPI::Exceptions::ParameterNotAllowed.new(:id)
+            else
+              params_not_allowed.push(:id)
               params.delete :id
             end
           end
         else
-          params_not_allowed.push(key)
+          if JSONAPI.configuration.raise_if_parameters_not_allowed
+            fail JSONAPI::Exceptions::ParameterNotAllowed.new(key)
+          else
+            params_not_allowed.push(key)
+            params.delete key
+          end
         end
       end
 
       if params_not_allowed.length > 0
-        if JSONAPI.configuration.raise_if_parameters_not_allowed
-          fail JSONAPI::Exceptions::ParametersNotAllowed.new(params_not_allowed)
-        else
-          params_not_allowed_warnings = params_not_allowed.map do |key|
-            JSONAPI::Warning.new(code: JSONAPI::PARAM_NOT_ALLOWED,
-                                 title: 'Param not allowed',
-                                 detail: "#{key} is not allowed.")
-          end
-          self.warnings.concat(params_not_allowed_warnings)
+        params_not_allowed_warnings = params_not_allowed.map do |param|
+          JSONAPI::Warning.new(code: JSONAPI::PARAM_NOT_ALLOWED,
+                               title: 'Param not allowed',
+                               detail: "#{param} is not allowed.")
         end
+        self.warnings.concat(params_not_allowed_warnings)
       end
     end
 
@@ -635,7 +703,8 @@ module JSONAPI
     end
 
     def parse_replace_operation(data, keys)
-      parse_single_replace_operation(data, [keys], id_key_presence_check_required: keys.present?)
+      parse_single_replace_operation(data, [keys],
+                                     id_key_presence_check_required: keys.present? && !@resource_klass.singleton?)
     rescue JSONAPI::Exceptions::Error => e
       @errors.concat(e.errors)
     end
@@ -666,6 +735,13 @@ module JSONAPI
       end
     end
 
+    def resolve_singleton_id(params)
+      if @resource_klass.singleton? && params[:id].nil?
+        key = @resource_klass.singleton_key(context)
+        params[:id] = key
+      end
+    end
+
     def format_key(key)
       @key_formatter.format(key)
     end

data/lib/jsonapi/resource.rb

@@ -5,6 +5,9 @@ module JSONAPI
   class Resource
     include Callbacks
 
+    DEFAULT_ATTRIBUTE_OPTIONS = { format: :default }.freeze
+    MODULE_PATH_REGEXP = /::[^:]+\Z/.freeze
+
     attr_reader :context
 
     define_jsonapi_resources_callbacks :create,
@@ -302,6 +305,26 @@ module JSONAPI
         to_add = relationship_key_values - (relationship_key_values & existing)
         _create_to_many_links(relationship_type, to_add, {})
 
+        @reload_needed = true
+      elsif relationship.polymorphic?
+        relationship_key_values.each do |relationship_key_value|
+          relationship_resource_klass = self.class.resource_for(relationship_key_value[:type])
+          ids = relationship_key_value[:ids]
+
+          related_records = relationship_resource_klass
+            .records(options)
+            .where({relationship_resource_klass._primary_key => ids})
+
+          missed_ids = ids - related_records.pluck(relationship_resource_klass._primary_key)
+
+          if missed_ids.present?
+            fail JSONAPI::Exceptions::RecordNotFound.new(missed_ids)
+          end
+
+          relation_name = relationship.relation_name(context: @context)
+          @model.send("#{relation_name}") << related_records
+        end
+
         @reload_needed = true
       else
         send("#{relationship.foreign_key}=", relationship_key_values)
@@ -415,6 +438,8 @@ module JSONAPI
         subclass.abstract(false)
         subclass.immutable(false)
         subclass.caching(false)
+        subclass.singleton(singleton?, (_singleton_options.dup || {}))
+        subclass.exclude_links(_exclude_links)
         subclass._attributes = (_attributes || {}).dup
 
         subclass._model_hints = (_model_hints || {}).dup
@@ -435,6 +460,9 @@ module JSONAPI
         end
 
         check_reserved_resource_name(subclass._type, subclass.name)
+
+        subclass._routed = false
+        subclass._warned_missing_route = false
       end
 
       def rebuild_relationships(relationships)
@@ -453,7 +481,7 @@ module JSONAPI
 
       def resource_for(type)
         type = type.underscore
-        type_with_module = type.include?('/') ? type : module_path + type
+        type_with_module = type.start_with?(module_path) ? type : module_path + type
 
         resource_name = _resource_name_from_type(type_with_module)
         resource = resource_name.safe_constantize if resource_name
@@ -480,7 +508,7 @@ module JSONAPI
         end
       end
 
-      attr_accessor :_attributes, :_relationships, :_type, :_model_hints
+      attr_accessor :_attributes, :_relationships, :_type, :_model_hints, :_routed, :_warned_missing_route
       attr_writer :_allowed_filters, :_paginator
 
       def create(context)
@@ -507,10 +535,12 @@ module JSONAPI
         end
       end
 
-      def attribute(attr, options = {})
+      def attribute(attribute_name, options = {})
+        attr = attribute_name.to_sym
+
         check_reserved_attribute_name(attr)
 
-        if (attr.to_sym == :id) && (options[:format].nil?)
+        if (attr == :id) && (options[:format].nil?)
           ActiveSupport::Deprecation.warn('Id without format is no longer supported. Please remove ids from attributes, or specify a format.')
         end
 
@@ -528,7 +558,7 @@ module JSONAPI
       end
 
       def default_attribute_options
-        { format: :default }
+        DEFAULT_ATTRIBUTE_OPTIONS
       end
 
       def relationship(*attrs)
@@ -563,7 +593,14 @@ module JSONAPI
         _add_relationship(Relationship::ToMany, *attrs)
       end
 
+      # @model_class is inherited from superclass, and this causes some issues:
+      # ```
+      # CarResource._model_class #=> Vehicle # it should be Car
+      # ```
+      # so in order to invoke the right class from subclasses,
+      # we should call this method to override it.
       def model_name(model, options = {})
+        @model_class = nil
         @_model_name = model.to_sym
 
         model_hint(model: @_model_name, resource: self) unless options[:add_model_hint] == false
@@ -577,6 +614,19 @@ module JSONAPI
         _model_hints[model.to_s.gsub('::', '/').underscore] = resource_type.to_s
       end
 
+      def singleton(*attrs)
+        @_singleton = (!!attrs[0] == attrs[0]) ? attrs[0] : true
+        @_singleton_options = attrs.extract_options!
+      end
+
+      def _singleton_options
+        @_singleton_options ||= {}
+      end
+
+      def singleton?
+        @_singleton ||= false
+      end
+
       def filters(*attrs)
         @_allowed_filters.merge!(attrs.inject({}) { |h, attr| h[attr] = {}; h })
       end
@@ -636,7 +686,7 @@ module JSONAPI
         include_directives = options[:include_directives]
         if include_directives
           model_includes = resolve_relationship_names_to_relations(self, include_directives.model_includes, options)
-          records = records.includes(model_includes)
+          records = records.includes(model_includes) if model_includes.present?
         end
 
         records
@@ -730,9 +780,30 @@ module JSONAPI
         records
       end
 
+      def apply_included_resources_filters(records, options = {})
+        include_directives = options[:include_directives]
+        return records unless include_directives
+        related_directives = include_directives.include_directives.fetch(:include_related)
+        related_directives.reduce(records) do |memo, (relationship_name, config)|
+          relationship = _relationship(relationship_name)
+          next memo unless relationship && relationship.is_a?(JSONAPI::Relationship::ToMany)
+          filtering_resource = relationship.resource_klass
+
+          # Don't try to merge where clauses when relation isn't already being joined to query.
+          next memo unless config[:include_in_join]
+
+          filters = config[:include_filters]
+          next memo unless filters
+
+          rel_records = filtering_resource.apply_filters(filtering_resource.records(options), filters, options).references(relationship_name)
+          memo.merge(rel_records)
+        end
+      end
+
       def filter_records(filters, options, records = records(options))
         records = apply_filters(records, filters, options)
-        apply_includes(records, options)
+        records = apply_includes(records, options)
+        apply_included_resources_filters(records, options)
       end
 
       def sort_records(records, order_options, context = {})
@@ -808,6 +879,9 @@ module JSONAPI
 
       def verify_filters(filters, context = nil)
         verified_filters = {}
+
+        return verified_filters if filters.nil?
+
         filters.each do |filter, raw_value|
           verified_filter = verify_filter(filter, raw_value, context)
           verified_filters[verified_filter[0]] = verified_filter[1]
@@ -855,6 +929,24 @@ module JSONAPI
         @_resource_key_type ||= JSONAPI.configuration.resource_key_type
       end
 
+      # override to all resolution of masked ids to actual ids. Because singleton routes do not specify the id this
+      # will be needed to allow lookup of singleton resources. Alternately singleton resources can override
+      # `verify_key`
+      def singleton_key(context)
+        if @_singleton_options && @_singleton_options[:singleton_key]
+          strategy = @_singleton_options[:singleton_key]
+          case strategy
+            when Proc
+              key = strategy.call(context)
+            when Symbol, String
+              key = send(strategy, context)
+            else
+              raise "singleton_key must be a proc or function name"
+          end
+        end
+        key
+      end
+
       def verify_key(key, context = nil)
         key_type = resource_key_type
 
@@ -906,6 +998,10 @@ module JSONAPI
         default_attribute_options.merge(@_attributes[attr])
       end
 
+      def _has_attribute?(attr)
+        @_attributes.keys.include?(attr.to_sym)
+      end
+
       def _updatable_relationships
         @_relationships.map { |key, _relationship| key }
       end
@@ -975,6 +1071,31 @@ module JSONAPI
         !@immutable
       end
 
+      def exclude_links(exclude)
+        _resolve_exclude_links(exclude)
+      end
+
+      def _exclude_links
+        @_exclude_links ||= _resolve_exclude_links(JSONAPI.configuration.default_exclude_links)
+      end
+
+      def exclude_link?(link)
+        _exclude_links.include?(link.to_sym)
+      end
+
+      def _resolve_exclude_links(exclude)
+        case exclude
+          when :default, "default"
+            @_exclude_links = [:self]
+          when :none, "none"
+            @_exclude_links = []
+          when Array
+            @_exclude_links = exclude.collect {|link| link.to_sym}
+          else
+            fail "Invalid exclude_links"
+        end
+      end
+
       def caching(val = true)
         @caching = val
       end
@@ -1015,7 +1136,7 @@ module JSONAPI
         if name == 'JSONAPI::Resource'
           ''
         else
-          name =~ /::[^:]+\Z/ ? ($`.freeze.gsub('::', '/') + '/').underscore : ''
+          name =~ MODULE_PATH_REGEXP ? ($`.freeze.gsub('::', '/') + '/').underscore : ''
         end
       end
 
@@ -1038,7 +1159,8 @@ module JSONAPI
         options = attrs.extract_options!
         options[:parent_resource] = self
 
-        attrs.each do |relationship_name|
+        attrs.each do |name|
+          relationship_name = name.to_sym
           check_reserved_relationship_name(relationship_name)
           check_duplicate_relationship_name(relationship_name)
 
@@ -1232,7 +1354,8 @@ module JSONAPI
               rel_id = row[index+1]
               assoc_rels = res.preloaded_fragments[rel_name]
               if index == path.length - 1
-                assoc_rels[rel_id] = target_resources[klass.name].fetch(rel_id)
+                association_res = target_resources[klass.name].fetch(rel_id, nil)
+                assoc_rels[rel_id] = association_res if association_res
               else
                 res = assoc_rels[rel_id]
               end
@@ -1246,7 +1369,7 @@ module JSONAPI
         quoted_attrs = attrs.map do |attr|
           quoted_table = conn.quote_table_name(attr.relation.table_alias || attr.relation.name)
           quoted_column = conn.quote_column_name(attr.name)
-          "#{quoted_table}.#{quoted_column}"
+          Arel.sql("#{quoted_table}.#{quoted_column}")
         end
         relation.pluck(*quoted_attrs)
       end

data/lib/jsonapi/resource_controller_metal.rb

@@ -5,10 +5,10 @@ module JSONAPI
       ActionController::Rendering,
       ActionController::Renderers::All,
       ActionController::StrongParameters,
-      ActionController::ForceSSL,
+      Gem::Requirement.new('< 6.1').satisfied_by?(ActionPack.gem_version) ? ActionController::ForceSSL : nil,
       ActionController::Instrumentation,
       JSONAPI::ActsAsResourceController
-    ].freeze
+    ].compact.freeze
 
     MODULES.each do |mod|
       include mod