praxis 2.0.pre.13 → 2.0.pre.17

data/lib/praxis/mapper/resource.rb

@@ -46,8 +46,8 @@ module Praxis::Mapper
       end
     end
 
-    def self.property(name, **options)
-      self.properties[name] = options
+    def self.property(name, dependencies: nil, through: nil)
+      self.properties[name] = {dependencies: dependencies, through: through}
     end
 
     def self._finalize!

data/lib/praxis/media_type_identifier.rb

@@ -198,10 +198,20 @@ module Praxis
       obj = self.class.new
       obj.type = self.type
       obj.subtype = self.subtype
-      obj.suffix = suffix || self.suffix || ''
+      target_suffix = suffix || self.suffix
+      obj.suffix = redundant_suffix(target_suffix) ? '' : target_suffix
       obj.parameters = self.parameters.merge(parameters)
 
       obj
     end
+
+    def redundant_suffix(suffix)
+      # application/json does not need to be suffixed with +json (same for application/xml)
+      # we're supporting text/json and text/xml for older formats as well
+      if (self.type == 'application' || self.type == 'text') && self.subtype == suffix
+        return true
+      end
+      false
+    end
   end
 end

data/lib/praxis/response_definition.rb

@@ -55,52 +55,36 @@ module Praxis
       end
     end
 
-    def location(loc=nil)
-      return @spec[:location] if loc.nil?
-      unless ( loc.is_a?(Regexp) || loc.is_a?(String) )
-        raise Exceptions::InvalidConfiguration.new(
-          "Invalid location specification. Location in response must be either a regular expression or a string."
-        )
-      end
-      @spec[:location] = loc
-    end
+    def location(loc=nil, description: nil)
+      return  headers.dig('Location',:value) if loc.nil?
 
-    def headers(hdrs = nil)
-      return @spec[:headers] if hdrs.nil?
+      header('Location', loc, description: description)
+    end
 
-      case hdrs
-      when Array
-        hdrs.each {|header_name| header(header_name) }
-      when Hash
-        header(hdrs)
-      when String
-        header(hdrs)
-      else
-        raise Exceptions::InvalidConfiguration.new(
-          "Invalid headers specification: Arrays, Hash, or String must be used. Received: #{hdrs.inspect}"
-        )
-      end
+    def headers
+      @spec[:headers]
     end
 
-    def header(hdr)
-      case hdr
-      when String
-        @spec[:headers][hdr] = true
-      when Hash
-        hdr.each do | k, v |
-          unless v.is_a?(Regexp) || v.is_a?(String)
-            raise Exceptions::InvalidConfiguration.new(
-              "Header definitions for #{k.inspect} can only match values of type String or Regexp. Received: #{v.inspect}"
-            )
-          end
-          @spec[:headers][k] = v
-        end
+    def header(name, value, description: nil)
+      the_type, args = case value
+      when nil,String
+        [String, {}]
+      when Regexp
+        # A regexp means it's gonna be a String typed, attached to a regexp
+        [String, { regexp: value }]
       else
         raise Exceptions::InvalidConfiguration.new(
-          "A header definition can only take a String (to match the name) or" +
-          " a Hash (to match both the name and the value). Received: #{hdr.inspect}"
+          "A header definition for a response can only take String, Regexp or nil values (to match anything)." +
+          "Received the following value for header name #{name}: #{value}"
         )
       end
+
+      info = { 
+        value: value, 
+        attribute: Attributor::Attribute.new(the_type, **args)
+      }
+      info[:description] = description if description
+      @spec[:headers][name] = info
     end
 
     def example(context=nil)
@@ -123,13 +107,14 @@ module Praxis
         :status => status,
         :headers => {}
       }
-      content[:location] = _describe_header(location) unless location == nil
 
       unless headers == nil
         headers.each do |name, value|
           content[:headers][name] = _describe_header(value)
         end
       end
+      content[:location] = content[:headers]['Location']
+
 
       if self.media_type
         payload = media_type.describe(true)
@@ -173,14 +158,14 @@ module Praxis
     end
 
     def _describe_header(data)
-      data_type = data.is_a?(Regexp) ? :regexp : :string
-      data_value = data.is_a?(Regexp) ? data.inspect : data
+
+      data_type = data[:value].is_a?(Regexp) ? :regexp : :string
+      data_value = data[:value].is_a?(Regexp) ? data[:value].inspect : data[:value]
       { :value => data_value, :type => data_type }
     end
 
     def validate(response, validate_body: false)
       validate_status!(response)
-      validate_location!(response)
       validate_headers!(response)
       validate_content_type!(response)
       validate_parts!(response)
@@ -222,23 +207,13 @@ module Praxis
       end
     end
 
-
-    # Validates 'Location' header
-    #
-    # @raise [Exceptions::Validation] When location header does not match to the defined one.
-    #
-    def validate_location!(response)
-      return if location.nil? || location === response.headers['Location']
-      raise Exceptions::Validation.new("LOCATION does not match #{location.inspect}")
-    end
-
-
     # Validates Headers
     #
     # @raise [Exceptions::Validation]  When there is a missing required header..
     #
     def validate_headers!(response)
       return unless headers
+
       headers.each do |name, value|
         if name.is_a? Symbol
           raise Exceptions::Validation.new(
@@ -252,20 +227,25 @@ module Praxis
           )
         end
 
-        case value
-        when String
-          if response.headers[name] != value
-            raise Exceptions::Validation.new(
-              "Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name]}."
-            )
-          end
-        when Regexp
-          if response.headers[name] !~ value
-            raise Exceptions::Validation.new(
-              "Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name].inspect}."
-            )
-          end
+        errors = value[:attribute].validate(response.headers[name])
+
+        unless errors.empty? 
+          raise Exceptions::Validation.new("Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name]}.")
         end
+        # case value
+        # when String
+        #   if response.headers[name] != value
+        #     raise Exceptions::Validation.new(
+        #       "Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name]}."
+        #     )
+        #   end
+        # when Regexp
+        #   if response.headers[name] !~ value
+        #     raise Exceptions::Validation.new(
+        #       "Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name].inspect}."
+        #     )
+        #   end
+        # end
       end
     end
 

data/lib/praxis/responses/http.rb

@@ -160,7 +160,9 @@ module Praxis
 
           media_type media_type if media_type
           location location if location
-          headers headers if headers
+          headers&.each do |(name, value)|
+            header(name: name, value: value)
+          end
         end
       end
 

data/lib/praxis/tasks/routes.rb

@@ -7,14 +7,14 @@ namespace :praxis do
     table = Terminal::Table.new title: "Routes",
     headings:  [
       "Version", "Path", "Verb",
-      "Resource", "Action", "Implementation", "Options"
+      "Endpoint", "Action", "Implementation", "Options"
     ]
 
     rows = []
-    Praxis::Application.instance.endpoint_definitions.each do |resource_definition|
-      resource_definition.actions.each do |name, action|
+    Praxis::Application.instance.endpoint_definitions.each do |endpoint_definition|
+      endpoint_definition.actions.each do |name, action|
         method = begin
-          m = resource_definition.controller.instance_method(name)
+          m = endpoint_definition.controller.instance_method(name)
         rescue
           nil
         end
@@ -22,13 +22,13 @@ namespace :praxis do
         method_name = method ? "#{method.owner.name}##{method.name}" : 'n/a'
 
         row = {
-          resource: resource_definition.name,
+          resource: endpoint_definition.name,
           action: name,
           implementation: method_name,
         }
 
         unless action.route
-          warn "Warning: No routes defined for #{resource_definition.name}##{name}."
+          warn "Warning: No routes defined for #{endpoint_definition.name}##{name}."
           rows << row
         else
           route = action.route

data/lib/praxis/version.rb

@@ -1,3 +1,3 @@
 module Praxis
-  VERSION = '2.0.pre.13'
+  VERSION = '2.0.pre.17'
 end

data/spec/praxis/action_definition_spec.rb

@@ -40,7 +40,9 @@ describe Praxis::ActionDefinition do
 
         media_type media_type
         location location
-        headers headers if headers
+        headers&.each do |(name, value)|
+          header(name, value)
+        end
       end
     end
     Praxis::ActionDefinition.new(:foo, endpoint_definition) do

data/spec/praxis/extensions/attribute_filtering/active_record_filter_query_builder_spec.rb

@@ -71,7 +71,7 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
             end
           end
         end
-          context 'that maps to a different name' do
+        context 'that maps to a different name' do
           let(:filters_string) { 'name=Book1'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.where(simple_name: 'Book1')
         end
@@ -79,6 +79,23 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
           let(:filters_string) { 'fake_nested.name=Book1'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.where(simple_name: 'Book1')
         end
+        context 'passing multiple values' do
+          context 'without fuzzy matching' do
+            let(:filters_string) { 'category_uuid=deadbeef1,deadbeef2' }
+            it_behaves_like 'subject_equivalent_to', ActiveBook.where(category_uuid: ['deadbeef1','deadbeef2'])
+          end
+          context 'with fuzzy matching' do
+            let(:filters_string) { 'category_uuid=*deadbeef1,deadbeef2*' }
+            it 'is not supported' do
+              expect{
+                subject
+              }.to raise_error(
+                Praxis::Extensions::AttributeFiltering::MultiMatchWithFuzzyNotAllowedByAdapter,
+                /Please use multiple OR clauses instead/
+              )
+            end
+          end
+        end
       end
 
       context 'by a field or a related model' do
@@ -94,6 +111,48 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
           let(:filters_string) { 'tags.name=blue' }
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:tags).where('active_tags.name' => 'blue')
         end
+
+        context 'by just an association filter condition' do
+          context 'for a belongs_to association with NO ROWS' do
+            let(:filters_string) { 'category!!'}
+            it_behaves_like 'subject_equivalent_to', ActiveBook.where.missing(:category)
+          end
+
+          context 'for a direct has_many association asking for missing rows' do
+            let(:filters_string) { 'primary_tags!!' }
+            it_behaves_like 'subject_equivalent_to', 
+              ActiveBook.where.missing(:primary_tags)
+          end
+          context 'for a direct has_many association asking for non-missing rows' do
+            let(:filters_string) { 'primary_tags!' }
+            it_behaves_like 'subject_equivalent_to', 
+              ActiveBook.left_outer_joins(:primary_tags).where.not('primary_tags.id' => nil)
+          end
+
+          context 'for a has_many through association with NO ROWS' do
+            let(:filters_string) { 'tags!!' }
+            it_behaves_like 'subject_equivalent_to', ActiveBook.where.missing(:tags)
+          end
+
+          context 'for a has_many through association with SOME ROWS' do
+            let(:filters_string) { 'tags!' }
+            it_behaves_like 'subject_equivalent_to', ActiveBook.left_outer_joins(:tags).where.not('tags.id' => nil)
+          end
+
+          context 'for a 3 levels deep has_many association with NO ROWS' do
+            let(:filters_string) { 'category.books.taggings!!' }
+            it_behaves_like 'subject_equivalent_to', 
+              ActiveBook.left_outer_joins(category: { books: :taggings }).where('category.books.taggings.id' => nil)
+          end
+          
+          context 'for a 3 levels deep has_many association WITH SIME ROWS' do
+            let(:filters_string) { 'category.books.taggings!' }
+            it_behaves_like 'subject_equivalent_to', 
+              ActiveBook.left_outer_joins(category: { books: :taggings }).where.not('category.books.taggings.id' => nil)
+          end
+          
+        end
+  
       end
 
       # NOTE: apparently AR when conditions are build with strings in the where clauses (instead of names, etc)
@@ -103,77 +162,77 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
         PREF = Praxis::Extensions::AttributeFiltering::ALIAS_TABLE_PREFIX
         COMMON_SQL_PREFIX = <<~SQL
               SELECT "active_books".* FROM "active_books"
-              INNER JOIN
+              LEFT OUTER JOIN
                 "active_authors" "#{PREF}/author" ON "#{PREF}/author"."id" = "active_books"."author_id"
             SQL
         context '=' do
           let(:filters_string) { 'author.id=11'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id = 11')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."id" = 11)
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."id" = 11)
             SQL
         end
         context '= (with array)' do
           let(:filters_string) { 'author.id=11,22'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id IN (11,22)')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."id" IN (11,22))
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."id" IN (11,22))
             SQL
         end      
         context '!=' do
           let(:filters_string) { 'author.id!=11'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id <> 11')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."id" <> 11)
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."id" <> 11)
             SQL
         end
         context '!= (with array)' do
           let(:filters_string) { 'author.id!=11,888'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id NOT IN (11,888)')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."id" NOT IN (11,888))
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."id" NOT IN (11,888))
             SQL
         end
         context '>' do
           let(:filters_string) { 'author.id>1'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id > 1')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."id" > 1)
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."id" > 1)
             SQL
         end
         context '<' do
           let(:filters_string) { 'author.id<22'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id < 22')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."id" < 22)
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."id" < 22)
             SQL
         end
         context '>=' do
           let(:filters_string) { 'author.id>=22'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id >= 22')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."id" >= 22)
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."id" >= 22)
             SQL
         end
         context '<=' do
           let(:filters_string) { 'author.id<=22'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id <= 22')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."id" <= 22)
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."id" <= 22)
             SQL
         end
         context '!' do
           let(:filters_string) { 'author.id!'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id IS NOT NULL')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."id" IS NOT NULL)
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."id" IS NOT NULL)
             SQL
         end
         context '!!' do
           let(:filters_string) { 'author.name!!'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name IS NULL')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."name" IS NULL)
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."name" IS NULL)
             SQL
         end      
         context 'including LIKE fuzzy queries' do
@@ -181,14 +240,14 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
             let(:filters_string) { 'author.name=author*'}
             it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name LIKE "author%"')
             it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."name" LIKE 'author%')
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."name" LIKE 'author%')
             SQL
           end
           context 'NOT LIKE' do
             let(:filters_string) { 'author.name!=foobar*'}
             it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name NOT LIKE "foobar%"')
             it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."name" NOT LIKE 'foobar%')
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."name" NOT LIKE 'foobar%')
             SQL
           end
         end
@@ -210,10 +269,10 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
             ActiveBook.joins(category: { books: :taggings }).where('active_taggings.tag_id': 1).where('active_taggings.label': 'primary')
           it_behaves_like 'subject_matches_sql', <<~SQL
               SELECT "active_books".* FROM "active_books"
-                INNER JOIN "active_categories" ON "active_categories"."uuid" = "active_books"."category_uuid"
-                INNER JOIN "active_books" "books_active_categories" ON "books_active_categories"."category_uuid" = "active_categories"."uuid"
-                INNER JOIN "active_taggings" "#{PREF}/category/books/taggings" ON "/category/books/taggings"."book_id" = "books_active_categories"."id"
-                WHERE ("#{PREF}/category/books/taggings"."tag_id" = 1)
+                LEFT OUTER JOIN "active_categories" ON "active_categories"."uuid" = "active_books"."category_uuid"
+                LEFT OUTER JOIN "active_books" "books_active_categories" ON "books_active_categories"."category_uuid" = "active_categories"."uuid"
+                LEFT OUTER JOIN "active_taggings" "#{PREF}/category/books/taggings" ON "/category/books/taggings"."book_id" = "books_active_categories"."id"
+                WHERE ("#{PREF}/category/books/taggings"."id" IS NOT NULL) AND ("#{PREF}/category/books/taggings"."tag_id" = 1)
                 AND ("#{PREF}/category/books/taggings"."label" = 'primary')
             SQL
         end
@@ -243,14 +302,14 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
                                                     .where('books_active_categories.simple_name': 'Book3')
           it_behaves_like 'subject_matches_sql', <<~SQL
               SELECT "active_books".* FROM "active_books"
-                INNER JOIN "active_categories" ON "active_categories"."uuid" = "active_books"."category_uuid"
-                INNER JOIN "active_books" "#{PREF}/category/books" ON "#{PREF}/category/books"."category_uuid" = "active_categories"."uuid"    
+                LEFT OUTER JOIN "active_categories" ON "active_categories"."uuid" = "active_books"."category_uuid"
+                LEFT OUTER JOIN "active_books" "#{PREF}/category/books" ON "#{PREF}/category/books"."category_uuid" = "active_categories"."uuid"    
               WHERE ("active_books"."simple_name" = 'Book1')
-              AND ("#{PREF}/category/books"."simple_name" = 'Book3')
+              AND ("#{PREF}/category/books"."id" IS NOT NULL) AND ("#{PREF}/category/books"."simple_name" = 'Book3')
             SQL
         end
 
-        context 'it qualifis them even if there are no joined tables/conditions at all' do
+        context 'it qualifies them even if there are no joined tables/conditions at all' do
           let(:filters_string) { 'id=11'}
           it_behaves_like 'subject_matches_sql', <<~SQL
             SELECT "active_books".* FROM "active_books"
@@ -293,20 +352,31 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
                                                 .or(ActiveBook.joins(:taggings).where('active_taggings.tag_id' => 2))
         it_behaves_like 'subject_matches_sql', <<~SQL
           SELECT "active_books".* FROM "active_books"
-            INNER JOIN "active_taggings" "/taggings" ON "/taggings"."book_id" = "active_books"."id"
-            WHERE ("/taggings"."label" = 'primary' OR "/taggings"."tag_id" = 2)
+            LEFT OUTER JOIN "active_taggings" "/taggings" ON "/taggings"."book_id" = "active_books"."id"
+            WHERE ("/taggings"."id" IS NOT NULL) AND ("/taggings"."label" = 'primary' OR "/taggings"."tag_id" = 2)
+        SQL
+      end
+
+      context 'works well with ORs at a parent table along with joined associations with no rows' do
+        let(:filters_string) { 'name=Book1005|category!!' }
+        it_behaves_like 'subject_equivalent_to', ActiveBook.where.missing(:category)
+                                                .or(ActiveBook.where.missing(:category).where(simple_name: "Book1005"))
+        it_behaves_like 'subject_matches_sql', <<~SQL
+          SELECT "active_books".* FROM "active_books"
+            LEFT OUTER JOIN "active_categories" "/category" ON "/category"."uuid" = "active_books"."category_uuid"
+            WHERE ("active_books"."simple_name" = 'Book1005' OR "/category"."uuid" IS NULL)
         SQL
       end
 
       context '3-deep AND and OR conditions' do
         let(:filters_string) { '(category.name=cat2|(taggings.label=primary&tags.name=red))&category_uuid=deadbeef1' }
         it_behaves_like('subject_equivalent_to', Proc.new do
-          base=ActiveBook.joins(:category,:taggings,:tags)
+          base=ActiveBook.left_outer_joins(:category,:taggings,:tags)
 
-          and1_or1 = base.where('category.name': 'cat2')
+          and1_or1 = base.where('category.name': 'cat2').where.not('category.uuid': nil)
 
-          and1_or2_and1 = base.where('taggings.label': 'primary')
-          and1_or2_and2 = base.where('tags.name': 'red')
+          and1_or2_and1 = base.where('taggings.label': 'primary').where.not('taggings.id': nil)
+          and1_or2_and2 = base.where('tags.name': 'red').where.not('tags.id': nil)
           and1_or2 = and1_or2_and1.and(and1_or2_and2)
 
           and1 = and1_or1.or(and1_or2)
@@ -317,11 +387,16 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
 
         it_behaves_like 'subject_matches_sql', <<~SQL
         SELECT "active_books".* FROM "active_books" 
-          INNER JOIN "active_categories" "/category" ON "/category"."uuid" = "active_books"."category_uuid" 
-          INNER JOIN "active_taggings" "/taggings" ON "/taggings"."book_id" = "active_books"."id" 
-          INNER JOIN "active_taggings" "taggings_active_books_join" ON "taggings_active_books_join"."book_id" = "active_books"."id" 
-          INNER JOIN "active_tags" "/tags" ON "/tags"."id" = "taggings_active_books_join"."tag_id"         
-          WHERE ("/category"."name" = 'cat2' OR ("/taggings"."label" = 'primary') AND ("/tags"."name" = 'red')) AND ("active_books"."category_uuid" = 'deadbeef1')
+          LEFT OUTER JOIN "active_categories" "/category" ON "/category"."uuid" = "active_books"."category_uuid" 
+          LEFT OUTER JOIN "active_taggings" "/taggings" ON "/taggings"."book_id" = "active_books"."id" 
+          LEFT OUTER JOIN "active_tags" "/tags" ON "/tags"."id" = "/taggings"."tag_id"         
+          WHERE (("/category"."uuid" IS NOT NULL)
+                AND ("/category"."name" = 'cat2')
+                  OR ("/taggings"."id" IS NOT NULL)
+                      AND ("/taggings"."label" = 'primary')
+                      AND ("/tags"."id" IS NOT NULL)
+                      AND ("/tags"."name" = 'red'))
+                AND ("active_books"."category_uuid" = 'deadbeef1') 
         SQL
       end
     end
@@ -374,9 +449,9 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
         # This is slightly incorrect in AR 6.1+ (since the picked aliases for active_taggings tables vary)
         # it_behaves_like 'subject_matches_sql', <<~SQL
         #   SELECT "active_books".* FROM "active_books"
-        #     INNER JOIN "active_taggings" ON "active_taggings"."label" = 'primary'
+        #     LEFT OUTER JOIN "active_taggings" ON "active_taggings"."label" = 'primary'
         #                 AND "active_taggings"."book_id" = "active_books"."id"
-        #     INNER JOIN "active_tags" "/primary_tags" ON "/primary_tags"."id" = "active_taggings"."tag_id"
+        #     LEFT OUTER JOIN "active_tags" "/primary_tags" ON "/primary_tags"."id" = "active_taggings"."tag_id"
         #     WHERE ("/primary_tags"."name" = 'blue')
         # SQL
       end