forest_liana 9.20.7 → 9.20.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed69fd6aba8fea8a03a02738a6f9ca6e75ae334980e501470dbabe1d58c37497
-  data.tar.gz: a6439711199628972e57f782968244c096566919801510d2193e3d16fbe5d800
+  metadata.gz: 8081936e6d6a125213c778a94576d1eaaf5560eb838a89563a6e113ab79a2e46
+  data.tar.gz: b5cb7df552d00872c40981ee37009b534bb5a254ee637d7dd39dd71b840f6124
 SHA512:
-  metadata.gz: e6101bb2d0ea3dfe2b3944cdf5d2ca3391ecd26450653517dd30553ffd4075dcb0cb23b6659996303259f6bd931c8054a58986f9337adc5417f94df8f1aac8b2
-  data.tar.gz: 3de7e6bc1710e6e8f8e1c8b1857775091e7d5d707d57c9f7f4dd1a993c7fbac111e350a88d4623e90357b8815aaf74a1de6a01710c01a81bd039b465ca19f600
+  metadata.gz: a1e231f576b02caed5a80f12fff4d6baabd4355ef9f5aae79afb3f4a6663e29cda2cdd078088e4949d42435c1bcf8f28b82bc7c90c619f971e17da7fa81bd45a
+  data.tar.gz: 0a93106150c9ead61198c464baaab09c0eb0974abc5c78570e980baa48bd3a05bdb4677720fa8b35704375665c06b297cad763325249601d08962222a9c444d4

data/app/services/forest_liana/filters_parser.rb

@@ -83,6 +83,10 @@ module ForestLiana
       value = condition['value']
       field_name = condition['field']
 
+      # NOTICE: captured before the enum mapping below, which turns an unknown
+      #         enum value into nil and would otherwise look like a null filter.
+      null_value = value.nil?
+
       if @operator_date_parser.is_date_operator?(operator)
         field_schema = SchemaUtils.find_column_schema_by_name(ForestLiana.name_for(@resource), field_name)
         condition = @operator_date_parser.get_date_filter(operator, value, field_schema)
@@ -99,6 +103,14 @@ module ForestLiana
 
       case_insensitive = operator == 'i_contains'
       parsed_field = parse_field_name(field_name, case_insensitive)
+
+      # NOTICE: the UI sends a null equality filter as a JSON null; `= NULL` and
+      #         `!= NULL` never match anything in SQL.
+      if null_value
+        return "#{parsed_field} IS NULL" if operator == 'equal'
+        return "#{parsed_field} IS NOT NULL" if operator == 'not_equal'
+      end
+
       parsed_operator = parse_operator(operator)
       parsed_value = parse_value(operator, value)
       field_and_operator = "#{parsed_field} #{parsed_operator}"

data/app/services/forest_liana/search_query_builder.rb

@@ -85,7 +85,7 @@ module ForestLiana
             !@resource.defined_enums[column.name][@search.downcase].nil?
             conditions << "#{column_name} =
               #{@resource.defined_enums[column.name][@search.downcase]}"
-          elsif !(column.respond_to?(:array) && column.array) && text_type?(column.type)
+          elsif !(column.respond_to?(:array) && column.array) && text_type?(column.type) && !malformed_uuid_search?
             conditions << "LOWER(#{column_name}) LIKE :search_value_for_string"
           end
         end
@@ -114,7 +114,7 @@ module ForestLiana
               resource = @resource.reflect_on_association(association.to_sym)
               unless (SchemaUtils.polymorphic?(resource))
                 resource.klass.columns.each do |column|
-                  if !(column.respond_to?(:array) && column.array) && text_type?(column.type)
+                  if !(column.respond_to?(:array) && column.array) && text_type?(column.type) && !malformed_uuid_search?
                     if @collection.search_fields.nil? || (association_search &&
                       association_search.include?(column.name))
                       conditions << association_search_condition(resource.table_name,
@@ -138,7 +138,7 @@ module ForestLiana
               unless association_search.empty?
                 resource = @resource.reflect_on_association(association.to_sym)
                 resource.klass.columns.each do |column|
-                  if !(column.respond_to?(:array) && column.array) && text_type?(column.type)
+                  if !(column.respond_to?(:array) && column.array) && text_type?(column.type) && !malformed_uuid_search?
                     if association_search.include?(column.name)
                       conditions << association_search_condition(resource.table_name,
                         column.name)
@@ -150,11 +150,18 @@ module ForestLiana
           end
         end
 
-        @records = @resource.where(
-          conditions.join(' OR '),
-          search_value_for_string: "%#{@search.downcase}%",
-          search_value_for_uuid: @search.to_s
-        ) unless conditions.empty?
+        if conditions.empty?
+          # NOTICE: a malformed-UUID search suppresses the only conditions it could
+          #         have produced (text LIKE scans); match nothing rather than fall
+          #         through to an unfiltered query that returns the whole table.
+          @records = @resource.none if malformed_uuid_search?
+        else
+          @records = @resource.where(
+            conditions.join(' OR '),
+            search_value_for_string: "%#{@search.downcase}%",
+            search_value_for_uuid: @search.to_s
+          )
+        end
       end
 
       @records
@@ -223,5 +230,17 @@ module ForestLiana
     def text_type?(type_sym)
       [:string, :text, :citext].include? type_sym
     end
+
+    # NOTICE: A search that is UUID-shaped but fails the strict REGEX_UUID (a
+    #         truncated or mistyped UUID) can never match a real UUID column and,
+    #         on text columns, only triggers `LOWER(col) LIKE '%…%'` sequential
+    #         scans that can hit the statement timeout. Valid UUIDs are excluded
+    #         so they keep matching UUIDs stored in varchar/text columns.
+    def malformed_uuid_search?
+      return false unless @search.is_a?(String)
+
+      @search.match?(/\A[0-9a-f]+-[0-9a-f]+-[0-9a-f]+-[0-9a-f]+-[0-9a-f]+\z/i) &&
+        !REGEX_UUID.match?(@search)
+    end
   end
 end

data/lib/forest_liana/version.rb

@@ -1,3 +1,3 @@
 module ForestLiana
-  VERSION = "9.20.7"
+  VERSION = "9.20.9"
 end

data/spec/services/forest_liana/filters_parser_spec.rb

@@ -45,6 +45,29 @@ module ForestLiana
             it { expect(parsed_filters.count).to eq 1 }
           end
 
+          context 'equal on a null value (JSON null from the UI)' do
+            before do
+              Tree.create!(name: nil, age: 42, island: Island.first)
+              Tree.create!(name: 'null', age: 43, island: Island.first)
+            end
+
+            let(:filters) { { 'field' => 'name', 'operator' => 'equal', 'value' => nil } }
+
+            it 'matches rows where the column IS NULL, not the literal string "null"' do
+              expect(parsed_filters.pluck(:name)).to eq([nil])
+            end
+          end
+
+          context 'not_equal on a null value (JSON null from the UI)' do
+            before { Tree.create!(name: nil, age: 42, island: Island.first) }
+
+            let(:filters) { { 'field' => 'name', 'operator' => 'not_equal', 'value' => nil } }
+
+            it 'matches rows where the column IS NOT NULL' do
+              expect(parsed_filters.pluck(:name)).to match_array(['Tree n1', 'Tree n2', 'Tree n3'])
+            end
+          end
+
           context 'greater_than' do
             let(:filters) { { 'field' => 'age', 'operator' => 'greater_than', 'value' => 2 } }
             it { expect(parsed_filters.count).to eq 2 }
@@ -107,6 +130,14 @@ module ForestLiana
             it { expect(parsed_filters.count).to eq 0 }
           end
 
+          context 'equal on an unknown enum value' do
+            # The enum mapping nils an unknown value; the null-filter guard is
+            # keyed on the pre-mapping value so it must NOT become `IS NULL`
+            # (that would wrongly match rows whose joined cutter is absent).
+            let(:filters) { { 'field' => 'cutter:title', 'operator' => 'equal', 'value' => 'not_a_title' } }
+            it { expect(parsed_filters.count).to eq 0 }
+          end
+
           context 'contains' do
             let(:filters) { { 'field' => 'owner:title', 'operator' => 'contains', 'value' => 'in' } }
             it { expect(parsed_filters.count).to eq 3 }

data/spec/services/forest_liana/search_query_builder_spec.rb

@@ -16,6 +16,50 @@ module ForestLiana
     end
 
     describe '#perform' do
+      context 'when the search is a malformed UUID' do
+        # UUID-shaped but fails the strict REGEX_UUID (mistyped/truncated group).
+        # Starts with a letter so #to_i is 0 and adds no integer-`id` condition,
+        # leaving the text LIKE scans as the only possible matches.
+        let(:params) { { search: 'abcdef12-3456-4ae-ad4f-5662757713a2', searchExtended: '0' } }
+
+        before do
+          Tree.create!(name: 'Oak')
+          Tree.create!(name: 'Elm')
+        end
+
+        after { Tree.destroy_all }
+
+        it 'matches nothing instead of returning the unfiltered table' do
+          expect(builder.perform(Tree.all).count).to eq(0)
+        end
+      end
+
+      context 'when searchExtended is on and the search is a malformed UUID' do
+        # HashWithIndifferentAccess: the code reads @params['searchExtended'] (string).
+        let(:params) do
+          ActiveSupport::HashWithIndifferentAccess.new(
+            search: 'abcdef12-3456-4ae-ad4f-5662757713a2', searchExtended: '1'
+          )
+        end
+        let(:builder) { described_class.new(params, [:owner], collection, user) }
+
+        before { Tree.create!(name: 'Oak') }
+
+        after { Tree.destroy_all }
+
+        it 'does not build LIKE scans on associated text columns either' do
+          expect(builder.perform(Tree.all).to_sql).not_to match(/LIKE/i)
+        end
+      end
+
+      context 'when the search is a valid UUID' do
+        let(:params) { { search: '75fbcb43-f6f8-4cd1-861f-09a61fd1ddad', searchExtended: '0' } }
+
+        it 'still builds a LIKE scan on text columns (UUIDs stored as text)' do
+          expect(builder.perform(Tree.all).to_sql).to match(/LIKE/i)
+        end
+      end
+
       context 'when a column is an array uuid type' do
         let(:array_uuid_column) do
           double('Column', name: 'attachment_ids', type: :uuid, array: true).tap do |col|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forest_liana
 version: !ruby/object:Gem::Version
-  version: 9.20.7
+  version: 9.20.9
 platform: ruby
 authors:
 - Sandro Munda
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-03 00:00:00.000000000 Z
+date: 2026-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails