katalyst-tables 3.2.0 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc8fcc04168c193e4efc390aea35902880a43634861792f099a6307deee8b1ce
-  data.tar.gz: 87a482c6703813d83cc99a71f54fc5eb23ec3fdb71d3aebd21ad0cf83afde7ce
+  metadata.gz: 99f68d6b448fc719638002da3066e01c14a1574b544748ecbc4a0b9e78546fa0
+  data.tar.gz: 43aeb38f258254e5e89462354cbb2be64960a09c377ef2ff7830512f6306815b
 SHA512:
-  metadata.gz: b48963d7042ca31ee030a5f8b822ec0a2869a80d5f488baff838d113c238df1629576e3c12b9927c34c51f0e2ff0d556b8335fd2525e61cc0339130e0ea22b8e
-  data.tar.gz: 6c88896aa14bdb09dc8495b730812909b2b97ce3b6819409032398e0dcb1f475de709b3394584f3a501ed88847a84dca4054232a5b8ef401e3a5560060ca3f04
+  metadata.gz: b06c5ee8b89b3c3faed076018a54a66782ab729ea5790c1dae276d8f308e5a72e3843e7b7e7815e549f3dbe66e68225893f8bb9375911b79676e64d06e8a7e0a
+  data.tar.gz: 052ca42441d1f7343700bc0dc6adaca48205470962964c27c82c1a3af3450ab50a38357d46cd950b91b5191f1dfd1ad063471b58fdeb5983b0e7a3a6bc598561

data/CHANGELOG.md

@@ -1,7 +1,24 @@
+## [3.3.0]
+- Custom types for collections which support extensions for filtering with ranges and arrays.
+
+Note that if you have custom types defined for use in your collections, this could be a breaking
+change. We recommend you change your types to inherit from `Katalyst::Tables::Collections::Type::Value`
+and register them with `Katalyst::Tables::Collections::Type`.
+
+`Query` and `Filtering` are still optional extensions. We recommend that you add them to a
+based collection class in your application, e.g. `Admin::Collection`.
+
 ## [3.2.0]
 - Enum columns
 - Filter component (still in development, optional extension)
 
+Note: this release adds a dedicated registry for collection filtering types 
+instead of using the default provided by ActiveModel.
+
+If you have custom types that you use with tables collections,
+you will need to register them with Katalyst::Tables::Collection::Type
+in an initializer or similar.
+
 ## [3.1.0]
 - Introduce summary tables
 - Update ruby requirement >= 3.3

data/README.md

@@ -37,6 +37,8 @@ This gem provides entry points for backend and frontend concerns:
 * `Katalyst::Tables::Frontend` provides `table_with` for inline table generation,
 * `Katalyst::Tables::Collection::Base` provides a default entry point for
   building collections in your controller actions
+* `Katalyst::Tables::Collection::Query` provides build-in query parsing and filtering
+  based on the attributes defined in your collection.
 
 ### Frontend
 
@@ -206,6 +208,29 @@ detect features such as sorting and generate the appropriate table header links.
 <%= table_with(collection:) %>
 ```
 
+### Query
+
+Include `Katalyst::Tables::Collection::Query` into your collection to add automatic
+query parsing and filtering based on the configured attributes. For example:
+
+```ruby
+class Collection < Katalyst::Tables::Collection::Base
+  include Katalyst::Tables::Collection::Query
+  
+  attribute :first_name, :string
+  attribute :created_at, :date
+end
+```
+
+With this definition and a text-input named `query`, your users can write tagged
+query expressions such as `first_name:Aaron` or `created_at:>2024-01-01` and these
+will be automatically parsed and applied to the collection attribute, and the collection
+will automatically generate and apply ActiveRecord conditions to filter the given scope.
+
+There's also a frontend utility, `filter_with(collection:)` that will generate the form
+and show a modal that helps users to interact with the query interface. More details available
+in the [query](docs/query.md) documentation.
+
 ## Summary tables
 You can use the `Katalyst::SummaryTableComponent` to render a single record utilizing all the functionality from the 
 `Katalyst::TableComponent`. 

data/app/assets/stylesheets/katalyst/tables/_filter.scss

@@ -26,6 +26,15 @@
     pointer-events: unset;
   }
 
+  table {
+    table-layout: fixed;
+  }
+
+  th.label,
+  th.key {
+    width: 15%;
+  }
+
   .footer {
     display: flex;
     justify-content: flex-end;

data/app/components/katalyst/tables/filter/modal_component.html.erb

@@ -2,17 +2,17 @@
   <table>
     <thead>
     <tr>
-      <th></th>
-      <th>Key</th>
-      <th>Values</th>
+      <th class="label"></th>
+      <th class="key">Key</th>
+      <th class="values">Values</th>
     </tr>
     </thead>
     <tbody>
     <% attributes.each do |key, attribute| %>
       <tr>
-        <th><%= collection.model.human_attribute_name(key) %></th>
-        <td><%= key %></td>
-        <td><%= values_for(key, attribute) %></td>
+        <th class="label"><%= collection.model.human_attribute_name(key) %></th>
+        <td class="key"><%= key %></td>
+        <td class="values"><%= values_for(key, attribute) %></td>
       </tr>
     <% end %>
     </tbody>

data/app/components/katalyst/tables/filter/modal_component.rb

@@ -30,27 +30,73 @@ module Katalyst
           }
         end
 
+        using Collection::Type::Helpers::Extensions
+
         def attributes
-          collection.class.attribute_types.except(*DEFAULT_ATTRIBUTES)
+          collection.class.attribute_types
+            .select { |_, a| a.filterable? && a.type != :search }
         end
 
         def values_for(key, attribute)
           values_method = "#{key.parameterize.underscore}_values"
-          if attribute.type == :boolean
+          if collection.respond_to?(values_method)
+            return scope_values(attribute, values_method)
+          end
+
+          case attribute.type
+          when :boolean
             render_options(true, false)
-          elsif collection.model.defined_enums.has_key?(key)
-            render_array(*collection.model.defined_enums[key].keys)
-          elsif collection.respond_to?(values_method)
-            if collection.class.enum_attribute?(key)
-              render_array(*collection.public_send(values_method))
-            else
-              render_options(*collection.public_send(values_method))
-            end
+          when :date
+            date_values
+          when :integer
+            integer_values(attribute)
+          when :float
+            float_values(attribute)
+          when :enum
+            enum_values(key)
+          when :string
+            string_values(attribute)
+          end
+        end
+
+        def scope_values(attribute, values_method)
+          values = collection.public_send(values_method)
+          attribute.multiple? ? render_array(*values) : render_options(*values)
+        end
+
+        def date_values
+          render_options("YYYY-MM-DD", ">YYYY-MM-DD", "<YYYY-MM-DD", "YYYY-MM-DD..YYYY-MM-DD")
+        end
+
+        def string_values(attribute)
+          options = render_options("example", '"an example"')
+          safe_join([options, attribute.exact? ? "(exact match)" : "(fuzzy match)"], " ")
+        end
+
+        def enum_values(key)
+          enums = collection.model.defined_enums
+
+          render_array(*enums[key].keys) if enums.has_key?(key)
+        end
+
+        def float_values(attribute)
+          if attribute.multiple?
+            render_array("0.5", "1", "...")
+          else
+            render_options("0.5", ">0.5", "<0.5", "-0.5..0.5")
+          end
+        end
+
+        def integer_values(attribute)
+          if attribute.multiple?
+            render_array("0", "1", "...")
+          else
+            render_options("10", ">10", "<10", "0..10")
           end
         end
 
         def render_option(value)
-          "<code>#{value}</code>".html_safe # rubocop:disable Rails/OutputSafety
+          tag.code(value.to_s)
         end
 
         def render_options(*values)

data/app/components/katalyst/tables/filter_component.html.erb

@@ -6,13 +6,11 @@
       <%= form.text_field(
             :query,
             type:         :search,
-            size:         :full,
-            label:        nil,
             autocomplete: "off",
             **input_attributes,
           ) %>
 
-      <%= form.submit("Apply") %>
+      <%= form.button("Apply", type: :submit, name: nil) %>
     <% end %>
   <% end %>
 

data/app/models/concerns/katalyst/tables/collection/core.rb

@@ -26,8 +26,22 @@ module Katalyst
             end
           end
 
-          def enum_attribute?(key)
-            _default_attributes[key].value.is_a?(::Array)
+          using Type::Helpers::Extensions
+
+          def attribute(name, type = nil, default: (no_default = true), **)
+            type = type.is_a?(Symbol) ? resolve_type_name(type, **) : type || Type::Value.new
+
+            default = type.default_value if no_default
+
+            default.nil? && no_default ? super(name, type, **) : super
+          end
+
+          private
+
+          # @override ActiveModel::AttributeRegistration::ClassMethods#resolve_type_name()
+          def resolve_type_name(name, **)
+            # note, this is Katalyst::Tables::Collection::Type, not ActiveModel::Type
+            Type.lookup(name, **)
           end
         end
 

data/app/models/concerns/katalyst/tables/collection/filtering.rb

@@ -6,8 +6,6 @@ module Katalyst
       module Filtering
         extend ActiveSupport::Concern
 
-        DEFAULT_ATTRIBUTES = %w[sort page query].freeze
-
         included do
           use(Filter)
         end
@@ -20,73 +18,12 @@ module Katalyst
           end
 
           def call(collection)
-            collection.class._default_attributes.each_value do |attribute|
-              key = attribute.name
-
-              next if DEFAULT_ATTRIBUTES.include?(key)
-
-              value = collection.attributes[key]
-
-              filter_attribute(collection, key, value, attribute.type.type)
+            collection.instance_variable_get(:@attributes).each_value do |attribute|
+              collection.items = attribute.type.filter(collection.items, attribute)
             end
 
             @app.call(collection)
           end
-
-          def filter_attribute(collection, key, value, type)
-            if key == "search"
-              search(collection, value)
-            elsif type == :string
-              filter_matches(collection, key, value)
-            elsif type == :boolean
-              filter_eq(collection, key, value) unless value.nil?
-            elsif value.present?
-              filter_eq(collection, key, value)
-            end
-          end
-
-          def search(collection, search)
-            return if search.blank? || !collection.searchable?
-
-            collection.items = collection.items.public_send(collection.config.search_scope, search)
-          end
-
-          def filter_matches(collection, key, value)
-            return if value.nil?
-
-            model, column = join_key(collection, key)
-            arel_column = model.arel_table[column]
-
-            collection.items = collection.items.where(arel_column.matches("%#{sanitize_sql_like(value)}%"))
-          end
-
-          def filter_eq(collection, key, value)
-            model, column = join_key(collection, key)
-
-            condition = if model.attribute_types.has_key?(column)
-                          model.where(column => value)
-                        else
-                          model.public_send(column, value)
-                        end
-
-            collection.items = collection.items.merge(condition)
-          end
-
-          private
-
-          def join_key(collection, key)
-            if key.include?(".")
-              table, column = key.split(".")
-              collection.items = collection.items.joins(table.to_sym)
-              [collection.items.reflections[table].klass, column]
-            else
-              [collection.items.model, key]
-            end
-          end
-
-          def column_for(key)
-            key.include?(".") ? key.split(".").last : key
-          end
         end
       end
     end

data/app/models/concerns/katalyst/tables/collection/pagination.rb

@@ -19,7 +19,7 @@ module Katalyst
         included do
           attr_accessor :pagination
 
-          attribute :page, :integer, default: 1
+          attribute :page, :integer, default: 1, filter: false
 
           config_accessor :paginate
         end

data/app/models/concerns/katalyst/tables/collection/query/parser.rb

@@ -25,6 +25,10 @@ module Katalyst
               break unless take_tagged || take_untagged
             end
 
+            if untagged.any? && (search = collection.class.search_attribute)
+              collection.assign_attributes(search => untagged.join(" "))
+            end
+
             self
           end
 
@@ -38,6 +42,8 @@ module Katalyst
             return unless query.scan(/(\w+(\.\w+)?):/)
 
             key, = query.values_at(1)
+            skip_whitespace
+
             parser_for(key).parse(query)
           end
 
@@ -49,10 +55,12 @@ module Katalyst
             untagged
           end
 
+          using Type::Helpers::Extensions
+
           def parser_for(key)
             attribute = collection.class._default_attributes[key]
 
-            if collection.class.enum_attribute?(key)
+            if attribute.type.multiple? || attribute.value.is_a?(::Array)
               ArrayValueParser.new(collection:, attribute:)
             else
               SingleValueParser.new(collection:, attribute:)

data/app/models/concerns/katalyst/tables/collection/query.rb

@@ -8,35 +8,26 @@ module Katalyst
 
         include Filtering
 
-        included do
-          config_accessor :search_scope
+        class_methods do
+          def search_attribute
+            _default_attributes.each_value do |attribute|
+              return attribute.name if attribute.type.type == :search
+            end
+          end
+        end
 
-          attribute :query, :string, default: ""
-          attribute :search, :string, default: ""
+        included do
+          attribute :query, :query, default: ""
 
           # Note: this is defined inline so that we can overwrite query=
           def query=(value)
             query = super
 
-            parser = Parser.new(self).parse(query)
-
-            if searchable? && parser.untagged.any?
-              self.search = parser.untagged.join(" ")
-            end
+            Parser.new(self).parse(query)
 
             query
           end
         end
-
-        # Returns true if the collection supports untagged searching. This
-        # requires config.search_scope to be set to the name of the scope to use
-        # in the target record for untagged text searches. If not set, untagged
-        # search terms will be silently ignored.
-        #
-        # @return [true, false]
-        def searchable?
-          config.search_scope.present?
-        end
       end
     end
   end

data/app/models/concerns/katalyst/tables/collection/sorting.rb

@@ -40,7 +40,7 @@ module Katalyst
         using SortParams
 
         included do
-          attribute :sort, :string
+          attribute :sort, :string, filter: false
 
           attr_reader :default_sort
         end

data/app/models/katalyst/tables/collection/type/boolean.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Collection
+      module Type
+        class Boolean < Value
+          include Helpers::Delegate
+          include Helpers::Multiple
+
+          def initialize(**)
+            super(**, delegate: ActiveModel::Type::Boolean)
+          end
+
+          def filter?(attribute, value)
+            (!value.nil? && !value.eql?([])) || attribute.came_from_user?
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/katalyst/tables/collection/type/date.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Collection
+      module Type
+        class Date < Value
+          def type
+            :date
+          end
+
+          def serialize(value)
+            if value.is_a?(Date)
+              value.to_fs(:db)
+            elsif value.is_a?(Range)
+              if value.begin.nil?
+                "<#{value.end.to_fs(:db)}"
+              elsif value.end.nil?
+                ">#{value.begin.to_fs(:db)}"
+              else
+                "#{value.begin.to_fs(:db)}..#{value.end.to_fs(:db)}"
+              end
+            else
+              value.to_s
+            end
+          end
+
+          private
+
+          ISO_DATE = /\A(\d{4})-(\d\d)-(\d\d)\z/
+          LOWER_BOUND = /\A>(\d{4})-(\d\d)-(\d\d)\z/
+          UPPER_BOUND = /\A<(\d{4})-(\d\d)-(\d\d)\z/
+          BOUNDED = /\A(\d{4})-(\d\d)-(\d\d)\.\.(\d{4})-(\d\d)-(\d\d)\z/
+
+          def cast_value(value)
+            return value unless value.is_a?(::String)
+
+            if value =~ ISO_DATE
+              new_date($1.to_i, $2.to_i, $3.to_i)
+            elsif value =~ LOWER_BOUND
+              (new_date($1.to_i, $2.to_i, $3.to_i)..)
+            elsif value =~ UPPER_BOUND
+              (..new_date($1.to_i, $2.to_i, $3.to_i))
+            elsif value =~ BOUNDED
+              (new_date($1.to_i, $2.to_i, $3.to_i)..new_date($4.to_i, $5.to_i, $6.to_i))
+            end
+          end
+
+          def new_date(year, mon, mday)
+            return nil if year.nil? || (year.zero? && mon.zero? && mday.zero?)
+
+            ::Date.new(year, mon, mday)
+          rescue ArgumentError, TypeError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/katalyst/tables/collection/type/enum.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Collection
+      module Type
+        class Enum < Value
+          include Helpers::Multiple
+
+          def initialize(multiple: true, **)
+            super
+          end
+
+          def type
+            :enum
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/katalyst/tables/collection/type/float.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Collection
+      module Type
+        class Float < Value
+          include Helpers::Delegate
+          include Helpers::Multiple
+
+          def initialize(**)
+            super(**, delegate: ActiveModel::Type::Float)
+          end
+
+          def serialize(value)
+            if value.is_a?(Range)
+              if value.begin.nil?
+                "<#{super(value.end)}"
+              elsif value.end.nil?
+                ">#{super(value.begin)}"
+              else
+                "#{super(value.begin)}..#{super(value.end)}"
+              end
+            else
+              super
+            end
+          end
+
+          private
+
+          FLOAT = /(-?\d+(?:\.\d+)?)/
+          SINGLE_VALUE = /\A#{FLOAT}\z/
+          LOWER_BOUND = /\A>#{FLOAT}\z/
+          UPPER_BOUND = /\A<#{FLOAT}\z/
+          BOUNDED = /\A#{FLOAT}\.\.#{FLOAT}\z/
+
+          def cast_value(value)
+            case value
+            when ::Range, ::Integer
+              value
+            when SINGLE_VALUE
+              super($1)
+            when LOWER_BOUND
+              ((super($1))..)
+            when UPPER_BOUND
+              (..(super($1)))
+            when BOUNDED
+              ((super($1))..(super($2)))
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/katalyst/tables/collection/type/helpers/delegate.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Collection
+      module Type
+        module Helpers
+          # Lifts a delegating type from value to arrays of values
+          module Delegate
+            delegate :type, to: :@delegate
+
+            def initialize(delegate:, **arguments)
+              super(**arguments)
+
+              @delegate = delegate.new(**arguments.except(:filter, :multiple, :scope))
+            end
+
+            using Extensions
+
+            def deserialize(value)
+              if multiple? && value.is_a?(::Array)
+                value.map { |v| @delegate.deserialize(v) }
+              else
+                @delegate.deserialize(value)
+              end
+            end
+
+            def serialize(value)
+              if multiple? && value.is_a?(::Array)
+                value.map { |v| @delegate.serialize(v) }
+              else
+                @delegate.serialize(value)
+              end
+            end
+
+            private
+
+            def cast_value(value)
+              if multiple? && value.is_a?(::Array)
+                value.map { |v| @delegate.cast(v) }
+              else
+                @delegate.cast(value)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/katalyst/tables/collection/type/helpers/extensions.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Collection
+      module Type
+        module Helpers
+          # Adds support default_value, multiple?, and filterable? to ActiveModel::Type::Value
+          module Extensions
+            refine(::ActiveModel::Type::Value) do
+              def default_value
+                nil
+              end
+
+              def multiple?
+                false
+              end
+
+              def filterable?
+                false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/katalyst/tables/collection/type/helpers/multiple.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Collection
+      module Type
+        module Helpers
+          # Adds support for multiple: true
+          module Multiple
+            def initialize(multiple: false, **)
+              super(**)
+
+              @multiple = multiple
+            end
+
+            def multiple?
+              @multiple
+            end
+
+            using Extensions
+
+            def default_value
+              multiple? ? [] : super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/katalyst/tables/collection/type/integer.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Collection
+      module Type
+        class Integer < Value
+          include Helpers::Delegate
+          include Helpers::Multiple
+
+          def initialize(**)
+            super(**, delegate: ActiveModel::Type::Integer)
+          end
+
+          def serialize(value)
+            if value.is_a?(Range)
+              if value.begin.nil?
+                "<#{super(value.end)}"
+              elsif value.end.nil?
+                ">#{super(value.begin)}"
+              else
+                "#{super(value.begin)}..#{super(value.end)}"
+              end
+            else
+              super
+            end
+          end
+
+          private
+
+          INTEGER = /(-?\d+)/
+          SINGLE_VALUE = /\A#{INTEGER}\z/
+          LOWER_BOUND = /\A>#{INTEGER}\z/
+          UPPER_BOUND = /\A<#{INTEGER}\z/
+          BOUNDED = /\A#{INTEGER}\.\.#{INTEGER}\z/
+
+          def cast_value(value)
+            case value
+            when ::Range, ::Integer
+              value
+            when SINGLE_VALUE
+              super($1)
+            when LOWER_BOUND
+              ((super($1))..)
+            when UPPER_BOUND
+              (..(super($1)))
+            when BOUNDED
+              ((super($1))..(super($2)))
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/katalyst/tables/collection/type/query.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Collection
+      module Type
+        class Query < Value
+          def type
+            :query
+          end
+
+          def filterable?
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/katalyst/tables/collection/type/search.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Collection
+      module Type
+        class Search < Value
+          # @overwrite Value.initialize() to require scope
+          # rubocop:disable Lint/UselessMethodDefinition
+          def initialize(scope:, **)
+            super
+          end
+          # rubocop:enable Lint/UselessMethodDefinition
+
+          def type
+            :search
+          end
+
+          def filter_condition(model, _, value)
+            model.public_send(scope, value)
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/katalyst/tables/collection/type/string.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Collection
+      module Type
+        class String < Value
+          include ActiveRecord::Sanitization::ClassMethods
+
+          attr_reader :exact
+          alias_method :exact?, :exact
+
+          delegate :type, :serialize, :deserialize, :cast, to: :@delegate
+
+          def initialize(exact: false, **)
+            super(**)
+
+            @exact = exact
+            @delegate = ActiveModel::Type::String.new
+          end
+
+          private
+
+          def filter_condition(model, column, value)
+            if exact? || scope
+              super
+            else
+              model.where(model.arel_table[column].matches("%#{sanitize_sql_like(value)}%"))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/katalyst/tables/collection/type/value.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Katalyst
+  module Tables
+    module Collection
+      module Type
+        class Value < ActiveModel::Type::Value
+          using Helpers::Extensions
+
+          attr_reader :scope
+
+          def initialize(scope: nil, filter: true)
+            super()
+
+            @scope = scope
+            @filterable = filter
+          end
+
+          def filterable?
+            @filterable
+          end
+
+          def filter?(attribute, value)
+            filterable? && (value.present? || attribute.came_from_user?)
+          end
+
+          def filter(scope, attribute)
+            value = filter_value(attribute)
+
+            return scope unless filter?(attribute, value)
+
+            scope, model, column = model_and_column_for(scope, attribute)
+            condition            = filter_condition(model, column, value)
+
+            scope.merge(condition)
+          end
+
+          private
+
+          def filter_value(attribute)
+            attribute.value
+          end
+
+          def filter_condition(model, column, value)
+            if value.nil?
+              model.none
+            elsif scope
+              model.public_send(scope, value)
+            else
+              model.where(column => value)
+            end
+          end
+
+          def model_and_column_for(scope, attribute)
+            if attribute.name.include?(".")
+              table, column = attribute.name.split(".")
+              [scope.joins(table.to_sym), scope.model.reflections[table].klass, column]
+            else
+              [scope, scope.model, attribute.name]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/katalyst/tables/collection/type.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "active_model/type"
+
+module Katalyst
+  module Tables
+    module Collection
+      # Based on ActiveModel::Type – provides a registry for Collection filtering
+      module Type
+        @registry = ActiveModel::Type::Registry.new
+
+        class << self
+          attr_accessor :registry # :nodoc:
+
+          def register(type_name, klass = nil, &)
+            registry.register(type_name, klass, &)
+          end
+
+          def lookup(...)
+            registry.lookup(...)
+          end
+
+          def default_value
+            @default_value ||= Value.new
+          end
+        end
+
+        register(:boolean, Type::Boolean)
+        register(:date, Type::Date)
+        register(:enum, Type::Enum)
+        register(:float, Type::Float)
+        register(:integer, Type::Integer)
+        register(:string, Type::String)
+        register(:query, Type::Query)
+        register(:search, Type::Search)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: katalyst-tables
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 3.3.0
 platform: ruby
 authors:
 - Katalyst Interactive
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-06-19 00:00:00.000000000 Z
+date: 2024-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: katalyst-html-attributes
@@ -132,6 +132,19 @@ files:
 - app/models/katalyst/tables/collection/array.rb
 - app/models/katalyst/tables/collection/base.rb
 - app/models/katalyst/tables/collection/filter.rb
+- app/models/katalyst/tables/collection/type.rb
+- app/models/katalyst/tables/collection/type/boolean.rb
+- app/models/katalyst/tables/collection/type/date.rb
+- app/models/katalyst/tables/collection/type/enum.rb
+- app/models/katalyst/tables/collection/type/float.rb
+- app/models/katalyst/tables/collection/type/helpers/delegate.rb
+- app/models/katalyst/tables/collection/type/helpers/extensions.rb
+- app/models/katalyst/tables/collection/type/helpers/multiple.rb
+- app/models/katalyst/tables/collection/type/integer.rb
+- app/models/katalyst/tables/collection/type/query.rb
+- app/models/katalyst/tables/collection/type/search.rb
+- app/models/katalyst/tables/collection/type/string.rb
+- app/models/katalyst/tables/collection/type/value.rb
 - config/importmap.rb
 - config/locales/tables.en.yml
 - lib/katalyst/tables.rb