praxis 2.0.pre.16 → 2.0.pre.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fe1ba3515514e34ad80775b6b68b4fe046fd1806c40d2345c4fa945d34ed92a
-  data.tar.gz: 11934130d0c527d1bc52020f393f2a5167ba3f88c876e81deaf7eaa05c518eff
+  metadata.gz: dafcffa2e0d146f5b601ed796cb482c5068482757fc2f88770783536da52ad7e
+  data.tar.gz: c6f8875641b0e418128dd8f8a923a3df639b1a409e65976472c24b6fac52f90e
 SHA512:
-  metadata.gz: a32c98bd77159e59c5192390c2eb683b62930cb3f4b30cbe680b63db5b0c076199b0fb63e5a0a55abb772a92cadef19a8f05d7cedf7eb8218f585ce8b7a01acf
-  data.tar.gz: 2a086210825ac166730d63b9ea7e5baa2420cdeb1772e434028b95de356ce69778d983fededb1125825f5b036bc0a0c13fc9b61536d77a31cc63cd87f6a48c02
+  metadata.gz: 4728bf36f52fd0bf1f73c9efe02190cde40308be2378232897570deab1aa9e5fcbd1ca2b4335b9ad168c4eedda18143a512512e6c132d851b6f6c9447e891d19
+  data.tar.gz: 1d689d714604b4841f4059b1ef9734f1ceae0a9afcc7e7d75286be28f67cfe2a51cb86fafdd6c66b2ac40acc72bd431c12ad1b33aa91990ceecd690abc9e01ad

data/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## next
 
+## 2.0.pre.17
+* Changed the Parameter Filtering to use left outer joins (and extra conditions), to allow for the proper results when OR clauses are involved in certain configurations.
+* Built support for allowing filtering directly on associations using `!` and `!!` operators. This allows to filter results where 
+there are no associated rows (`!!`) or if there are some associated rows (`!`)
+* Allow implicit definition of `filters_mapping` for filter names that match top-level associations of the model (i.e., like we do for the columns)
 ## 2.0.pre.16
 
 * Updated `Resource.property` signature to only accept known named arguments (`dependencies` and `though` at this time) to spare anyone else from going insane wondering why their `depednencies` aren't working.

data/lib/praxis/extensions/attribute_filtering/active_record_filter_query_builder.rb

@@ -49,9 +49,8 @@ module Praxis
         end
 
         def craft_filter_query(nodetree, for_model:)
-          result = _compute_joins_and_conditions_data(nodetree, model: for_model)
+          result = _compute_joins_and_conditions_data(nodetree, model: for_model, parent_reflection: nil)
           return @initial_query if result[:conditions].empty?
-
           
           # Find the root group (usually an AND group) but can be an OR group, or nil if there's only 1 condition
           root_parent_group = result[:conditions].first[:node_object].parent_group || result[:conditions].first[:node_object]
@@ -60,13 +59,21 @@ module Praxis
           end
 
           # Process the joins
-          query_with_joins = result[:associations_hash].empty? ? @initial_query : @initial_query.joins(result[:associations_hash])
+          query_with_joins = result[:associations_hash].empty? ? @initial_query : @initial_query.left_outer_joins(result[:associations_hash])
 
           # Proc to apply a single condition
           apply_single_condition = Proc.new do |condition, associated_query|
             colo = condition[:model].columns_hash[condition[:name].to_s]
             column_prefix = condition[:column_prefix]
-            
+            association_key_column = \
+              if ref = condition[:parent_reflection]
+                # get the target model of the association(where the assoc pk is)
+                target_model = condition[:parent_reflection].klass
+                target_model.columns_hash[condition[:parent_reflection].association_primary_key]
+              else
+                nil
+              end
+
             # Mark where clause referencing the appropriate alias IF it's not the root table, as there is no association to reference
             # If we added root table as a reference, we better make sure it is not quoted, as it actually makes AR to see it as an 
             # unmatched reference and eager loads the whole association (it means eager load ALL the things). Not good.
@@ -79,7 +86,8 @@ module Praxis
               column_object: colo, 
               op: condition[:op], 
               value: condition[:value],
-              fuzzy: condition[:fuzzy]
+              fuzzy: condition[:fuzzy],
+              association_key_column: association_key_column,
             )
           end
 
@@ -144,7 +152,8 @@ module Praxis
         def _mapped_filter(name)
           target = @filters_map[name]
           unless target
-            if @model.attribute_names.include?(name.to_s)
+            filter_name = name.to_s
+            if (@model.attribute_names + @model.reflections.keys).include?(filter_name)
               # Cache it in the filters mapping (to avoid later lookups), and return it.
               @filters_map[name] = name
               target = name
@@ -182,31 +191,64 @@ module Praxis
         end
 
         # Calculate join tree and conditions array for the nodetree object and its children
-        def _compute_joins_and_conditions_data(nodetree, model:)
+        def _compute_joins_and_conditions_data(nodetree, model:, parent_reflection:)
           h = {}
           conditions = []
           nodetree.children.each do |name, child|
-            child_model = model.reflections[name.to_s].klass
-            result = _compute_joins_and_conditions_data(child, model: child_model)
-            h[name] = result[:associations_hash] 
+            child_reflection = model.reflections[name.to_s]
+            result = _compute_joins_and_conditions_data(child, model: child_reflection.klass, parent_reflection: child_reflection)
+            h[name] = result[:associations_hash]
+            
             conditions += result[:conditions]
           end
+          
           column_prefix = nodetree.path == [ALIAS_TABLE_PREFIX] ? model.table_name : nodetree.path.join(REFERENCES_STRING_SEPARATOR)
           nodetree.conditions.each do |condition|
-            conditions += [condition.merge(column_prefix: column_prefix, model: model)]
+            # If it's a final ! or !! operation on an association from the parent, it means we need to add a condition
+            # on the existence (or lack of) of the whole associated table
+            ref = model.reflections[condition[:name].to_s]
+            if ref && ['!','!!'].include?(condition[:op])
+              cp = (nodetree.path + [condition[:name].to_s]).join(REFERENCES_STRING_SEPARATOR)
+              conditions += [condition.merge(column_prefix: cp, model: model, parent_reflection: ref)]
+              h[condition[:name]] = {}
+            else
+              # Save the parent reflection where the condition applies as well (used later to get assoc keys)
+              conditions += [condition.merge(column_prefix: column_prefix, model: model, parent_reflection: parent_reflection)]
+            end
+            
           end
           {associations_hash: h, conditions: conditions}
         end
 
-        def self.add_clause(query:, column_prefix:, column_object:, op:, value:,fuzzy:)
+        def self.add_clause(query:, column_prefix:, column_object:, op:, value:,fuzzy:, association_key_column:)
           likeval = get_like_value(value,fuzzy)
+
+          association_op = nil
           case op
           when '!' # name! means => name IS NOT NULL (and the incoming value is nil)
             op = '!='
             value = nil # Enforce it is indeed nil (should be)
+            association_op = :not_null if association_key_column && !column_object
           when '!!'
             op = '='
             value = nil # Enforce it is indeed nil (should be)
+            association_op = :null if association_key_column && !column_object
+          end
+
+          if association_op
+            neg = association_op == :not_null ? true : false
+            qr = quote_right_part(query: query, value: nil, column_object: association_key_column, negative: neg)
+            return query.where("#{quote_column_path(query: query, prefix: column_prefix, column_object: association_key_column)} #{qr}")
+          end
+
+          # Add an AND along with the condition, which ensures the left outter join 'exists' for it
+          # Normally this wouldn't be necessary as a condition on a given value mathing would imply the related row was there
+          # but this is not the case for NULL conditions, as the foreign column would match a  NULL value, but not because the related column
+          # is NULL, but because the whole missing related row would appear with all fields null
+          # NOTE: we don't need to do it for conditions applying to the root of the tree (there isn't a join to it)
+          if association_key_column
+            qr = quote_right_part(query: query, value: nil, column_object: association_key_column, negative: true)
+            query = query.where("#{quote_column_path(query: query, prefix: column_prefix, column_object: association_key_column)} #{qr}")
           end
 
           case op

data/lib/praxis/version.rb

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

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

@@ -111,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)
@@ -120,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
@@ -198,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
@@ -227,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
@@ -260,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"
@@ -310,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)
@@ -334,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
@@ -391,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

data/spec/praxis/extensions/support/spec_resources_active_model.rb

@@ -120,6 +120,8 @@ class ActiveBookResource < ActiveBaseResource
     'category.books.name': 'category.books.simple_name',
     'category.books.taggings.tag_id': 'category.books.taggings.tag_id',
     'category.books.taggings.label': 'category.books.taggings.label',
+    'primary_tags': 'primary_tags',
+    'category.books.taggings': 'category.books.taggings',
   )
   # Forces to add an extra column (added_column)...and yet another (author_id) that will serve
   # to check that if that's already automatically added due to an association, it won't interfere or duplicate

data/spec/spec_helper.rb

@@ -17,6 +17,7 @@ require 'simplecov'
 SimpleCov.start 'praxis'
 
 require 'pry'
+require 'pry-byebug'
 
 require 'praxis'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: praxis
 version: !ruby/object:Gem::Version
-  version: 2.0.pre.16
+  version: 2.0.pre.17
 platform: ruby
 authors:
 - Josep M. Blanquer
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-13 00:00:00.000000000 Z
+date: 2021-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack