rokaki 0.14.0 → 0.16.0

data/docs/usage.md

@@ -11,7 +11,7 @@ This page shows how to use Rokaki to define filters and apply them to ActiveReco
 Add the gem to your Gemfile and bundle:
 
 ```ruby
-gem "rokaki", "~> 0.13"
+gem "rokaki", "~> 0.15"
 ```
 
 ```bash
@@ -31,8 +31,9 @@ class ArticleQuery
   include Rokaki::FilterModel
   belongs_to :author
 
-  # Choose model and adapter
-  filter_model :article, db: :postgres # or :mysql, :sqlserver
+  # Choose model; adapter is auto-detected from the model's connection.
+  # If your app uses multiple adapters, pass db: explicitly (e.g., db: :postgres)
+  filter_model :article
 
   # Map a single query key (:q) to multiple LIKE targets
   define_query_key :q
@@ -112,8 +113,9 @@ Rokaki also supports a block-form DSL that is equivalent to the argument-based f
 class ArticleQuery
   include Rokaki::FilterModel
 
-  # Choose model and adapter
-  filter_model :article, db: :postgres # or :mysql, :sqlserver
+  # Choose model; adapter is auto-detected from the model's connection.
+  # If your app uses multiple adapters, pass db: explicitly (e.g., db: :postgres)
+  filter_model :article
 
   # Declare a single query key used by all LIKE/equality filters below
   define_query_key :q
@@ -186,3 +188,122 @@ f.__author__location__city      # => 'London'
 Tips:
 - `filter_key_prefix` and `filter_key_infix` control the generated accessor names.
 - Inside the block, `nested :association` affects all `filters` declared within it.
+
+
+## Backend auto-detection
+
+By default, Rokaki auto-detects which database adapter to use from your model’s ActiveRecord connection. This means you usually don’t need to pass `db:` explicitly.
+
+- Single-adapter apps: No configuration needed — Rokaki infers the adapter from the model connection.
+- Multi-adapter apps: If more than one adapter is detected in the process, Rokaki raises a clear error asking you to declare which backend to use.
+- Explicit override: You can always specify `db:` on `filter_model` or call `filter_db` later.
+
+Examples:
+
+```ruby
+class ArticleQuery
+  include Rokaki::FilterModel
+
+  # Adapter auto-detected (recommended default)
+  filter_model :article
+  define_query_key :q
+
+  filter_map do
+    like title: :circumfix
+  end
+end
+```
+
+Explicit selection/override:
+
+```ruby
+class ArticleQuery
+  include Rokaki::FilterModel
+
+  # Option A: choose upfront
+  filter_model :article, db: :postgres
+
+  # Option B: or set it later
+  # filter_model :article
+  # filter_db :sqlite
+end
+```
+
+Ambiguity behavior (apps with multiple adapters):
+
+- If Rokaki sees multiple adapters in use and you haven’t specified one, it raises:
+
+```
+Rokaki::Error: Multiple database adapters detected (...). Please declare which backend to use via db: or filter_db.
+```
+
+- If it cannot detect any adapter at all, it raises:
+
+```
+Rokaki::Error: Unable to auto-detect database adapter. Ensure your model is connected or pass db: explicitly.
+```
+
+## Dynamic runtime listener (no code changes needed)
+
+You can construct a Rokaki filter class at runtime from a payload (e.g., JSON → Hash) and use it immediately — no prior class is required. Rokaki will compile the tiny class on the fly and generate the methods once.
+
+### FilterModel example
+```ruby
+# Example payload (e.g., parsed JSON)
+payload = {
+  model: :article,
+  db: :postgres,        # optional; or :mysql, :sqlserver, :oracle, :sqlite
+  query_key: :q,        # the key in params with search term(s)
+  like: {               # like mappings (deeply nested allowed)
+    title: :circumfix,
+    author: { first_name: :prefix }
+  }
+}
+
+# Build an anonymous class at runtime and use it immediately
+listener = Class.new do
+  include Rokaki::FilterModel
+
+  filter_model payload[:model], db: payload[:db]
+  define_query_key payload[:query_key]
+
+  filter_map do
+    like payload[:like]
+  end
+
+  attr_accessor :filters
+  def initialize(filters: {})
+    @filters = filters
+  end
+end
+
+results = listener.new(filters: { q: ["Ada", "Turing"] }).results
+# => ActiveRecord::Relation
+```
+
+### Filterable example (no SQL)
+```ruby
+mapper = Class.new do
+  include Rokaki::Filterable
+  filter_key_prefix :__
+
+  filter_map do
+    filters :date, author: [:first_name, :last_name]
+  end
+
+  attr_reader :filters
+  def initialize(filters: {})
+    @filters = filters
+  end
+end
+
+m = mapper.new(filters: { date: '2025-01-01', author: { first_name: 'Ada', last_name: 'Lovelace' } })
+m.__date                   # => '2025-01-01'
+m.__author__first_name     # => 'Ada'
+m.__author__last_name      # => 'Lovelace'
+```
+
+Notes:
+- This approach is production‑ready and requires no core changes to Rokaki.
+- You can cache the generated class by a digest of the payload to avoid recompiling.
+- For maximum safety, validate/allow‑list models/columns coming from untrusted payloads.

data/lib/rokaki/filter_model/nested_like_filters.rb

@@ -222,12 +222,25 @@ module Rokaki
             leaf: leaf
           )
 
-          if join_map.empty?
-            filter_query = "@model.#{query}"
-          elsif join_map.is_a?(Array)
-            filter_query = "@model.joins(*#{join_map}).#{query}"
+          # Compose filter_query based on adapter; for generic adapters use generic_like to support array values
+          if db == :postgres || db == :mysql
+            if join_map.empty?
+              filter_query = "@model.#{query}"
+            elsif join_map.is_a?(Array)
+              filter_query = "@model.joins(*#{join_map}).#{query}"
+            else
+              filter_query = "@model.joins(**#{join_map}).#{query}"
+            end
           else
-            filter_query = "@model.joins(**#{join_map}).#{query}"
+            # Generic (e.g., SQLite)
+            if join_map.empty?
+              rel_expr = "@model"
+            elsif join_map.is_a?(Array)
+              rel_expr = "@model.joins(*#{join_map})"
+            else
+              rel_expr = "@model.joins(**#{join_map})"
+            end
+            filter_query = "generic_like(#{rel_expr}, \"#{key_leaf}\", \"#{type.to_s.upcase}\", #{filter_name}, :#{search_mode})"
           end
         end
 
@@ -247,17 +260,9 @@ module Rokaki
         elsif db == :mysql
           query = "where(\"#{key_leaf} #{type.to_s.upcase} :query\", "
           query += "query: prepare_regex_terms(#{filter}, :#{search_mode}))"
-        else # :sqlserver and others
-          query = "where(\"#{key_leaf} #{type.to_s.upcase} :query\", "
-          if search_mode == :circumfix
-            query += "query: \"%\#{#{filter}}%\")"
-          elsif search_mode == :prefix
-            query += "query: \"%\#{#{filter}}\")"
-          elsif search_mode == :suffix
-            query += "query: \"\#{#{filter}}%\")"
-          else
-            query += "query: \"%\#{#{filter}}%\")"
-          end
+        else # generic adapters (e.g., SQLite): delegate to generic_like to support array values via OR
+          # We return a marker here; the caller (build_query) will assemble the full expression with joins
+          query = nil
         end
 
         query

data/lib/rokaki/filter_model.rb

@@ -90,6 +90,24 @@ module Rokaki
       end
     end
 
+    # Compose a generic LIKE relation supporting arrays of terms (OR chained)
+    # Used for adapters without special handling (e.g., SQLite)
+    def generic_like(model, column, type, value, mode)
+      terms = prepare_terms(value, mode)
+      return model.none if terms.nil?
+      if terms.is_a?(Array)
+        return model.none if terms.empty?
+        rel = model.where("#{column} #{type} :q0", q0: terms[0])
+        terms[1..-1]&.each_with_index do |t, i|
+          rel = rel.or(model.where("#{column} #{type} :q#{i + 1}", "q#{i + 1}".to_sym => t))
+        end
+        rel
+      else
+        # prepare_terms returns arrays for scalar input, so this branch is rarely used
+        model.where("#{column} #{type} :q", q: terms)
+      end
+    end
+
     def prepare_regex_terms(param, mode)
       if Array === param
         param_map = param.map { |term| ".*#{term}.*" } if mode == :circumfix
@@ -141,6 +159,89 @@ module Rokaki
         end
       end
 
+      # Map AR adapter names to internal symbols
+      def map_adapter_name(name)
+        n = name.to_s.downcase
+        case n
+        when 'postgresql', 'postgres', 'postgis'
+          :postgres
+        when 'mysql2', 'mysql'
+          :mysql
+        when 'sqlite3', 'sqlite'
+          :sqlite
+        when 'sqlserver'
+          :sqlserver
+        when 'oracle_enhanced', 'oracle'
+          :oracle
+        else
+          nil
+        end
+      end
+
+      # Try to detect adapter from a model's connection
+      def detect_adapter_from_model(model)
+        return nil unless model
+        begin
+          adapter = model.connection_db_config&.adapter
+          return map_adapter_name(adapter) if adapter
+        rescue StandardError
+          # fall through
+        end
+        begin
+          adapter = model.connection&.adapter_name
+          return map_adapter_name(adapter)
+        rescue StandardError
+          nil
+        end
+      end
+
+      # Scan known AR models to see how many adapters are in use
+      def adapters_in_use
+        adapters = []
+        begin
+          bases = [::ActiveRecord::Base] + (::ActiveRecord::Base.descendants rescue [])
+          bases.uniq.each do |k|
+            next unless k.respond_to?(:connection_db_config)
+            begin
+              a = k.connection_db_config&.adapter
+              adapters << a if a
+            rescue StandardError
+              # ignore not connected models
+            end
+          end
+        rescue StandardError
+          # ignore
+        end
+        adapters.compact.map { |a| map_adapter_name(a) }.compact.uniq
+      end
+
+      # Determine @_filter_db or raise if ambiguous in multi-adapter apps
+      def resolve_filter_db!(model: @model, explicit: nil)
+        if explicit
+          @_filter_db = explicit
+          return @_filter_db
+        end
+        # Prefer model-specific detection
+        detected = detect_adapter_from_model(model)
+        return (@_filter_db = detected) if detected
+
+        # Fallback to a single global adapter if unambiguous
+        used = adapters_in_use
+        if used.size == 1
+          @_filter_db = used.first
+        elsif used.size > 1
+          raise ::Rokaki::Error, "Multiple database adapters detected (#{used.join(', ')}). Please declare which backend to use via db: or filter_db."
+        else
+          # As a last resort, try ActiveRecord::Base connection
+          begin
+            base_detected = map_adapter_name(::ActiveRecord::Base.connection_db_config&.adapter)
+            return (@_filter_db = base_detected) if base_detected
+          rescue StandardError
+          end
+          raise ::Rokaki::Error, "Unable to auto-detect database adapter. Ensure your model is connected or pass db: explicitly."
+        end
+      end
+
       # Merge two nested like/ilike mappings
       def deep_merge_like(a, b)
         return b if a.nil? || a == {}
@@ -178,7 +279,7 @@ module Rokaki
         if block_given? && args.empty?
           raise ArgumentError, 'define_query_key must be called before block filter_map' unless @filter_map_query_key
           raise ArgumentError, 'filter_model must be called before block filter_map' unless @model
-          @_filter_db ||= :postgres
+          resolve_filter_db!(model: @model)
 
           # Enter block-collection mode
           @__in_filter_map_block = true
@@ -210,22 +311,22 @@ module Rokaki
         filter_model(model)
         @filter_map_query_key = query_key
 
-        @_filter_db = options[:db] || :postgres
-        @_filter_mode = options[:mode] || :and
-        like(options[:like]) if options[:like]
-        ilike(options[:ilike]) if options[:ilike]
-        filters(*options[:match]) if options[:match]
+        resolve_filter_db!(model: @model, explicit: options && options[:db])
+        @_filter_mode = (options && options[:mode]) || :and
+        like(options[:like]) if options && options[:like]
+        ilike(options[:ilike]) if options && options[:ilike]
+        filters(*options[:match]) if options && options[:match]
       end
 
       def filter(model, options)
         filter_model(model)
         @filter_map_query_key = nil
 
-        @_filter_db = options[:db] || :postgres
-        @_filter_mode = options[:mode] || :and
-        like(options[:like]) if options[:like]
-        ilike(options[:ilike]) if options[:ilike]
-        filters(*options[:match]) if options[:match]
+        resolve_filter_db!(model: @model, explicit: options && options[:db])
+        @_filter_mode = (options && options[:mode]) || :and
+        like(options[:like]) if options && options[:like]
+        ilike(options[:ilike]) if options && options[:ilike]
+        filters(*options[:match]) if options && options[:match]
       end
 
       def filters(*filter_keys)
@@ -335,9 +436,10 @@ module Rokaki
       end
 
       def filter_model(model_class, db: nil)
-        @_filter_db = db if db
         @model = (model_class.is_a?(Class) ? model_class : Object.const_get(model_class.capitalize))
         class_eval "def set_model; @model ||= #{@model}; end;"
+        # Only resolve here if an explicit db is provided; otherwise defer to callers
+        resolve_filter_db!(model: @model, explicit: db) if db
       end
 
       def case_sensitive

data/lib/rokaki/version.rb

@@ -1,3 +1,3 @@
 module Rokaki
-  VERSION = "0.14.0"
+  VERSION = "0.16.0"
 end

data/rokaki.gemspec

@@ -1,4 +1,4 @@
-# frozen_string_literal: true
+  # frozen_string_literal: true
 
 lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rokaki
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.16.0
 platform: ruby
 authors:
 - Steve Martin
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-10-25 00:00:00.000000000 Z
+date: 2025-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -287,6 +287,7 @@ files:
 - Gemfile.lock
 - Guardfile
 - LICENSE.txt
+- README.legacy.md
 - README.md
 - Rakefile
 - bin/console