rokaki 0.16.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6c0197e9af455ef746957b92e5a28a4aa8a34ad35712c2aacae5ad6797f4d18
-  data.tar.gz: 7cc5acc3e65cd850a50de797285c55fdbdab9c47fc2a790a68d6ec23c4064b4d
+  metadata.gz: 1c59d25915c0eda9030515a3b92835664ab91951cc51faf13be126bbc0f6053c
+  data.tar.gz: 38e490b4dc7cbe7a1303d03af2f5fa7f41f8100ac4b5787f36b9b3e2d1cf8648
 SHA512:
-  metadata.gz: addeae565323de0ce359cd73d01e3c7e31f457849b59fb373942436358561fd085fcf36117a4c8c75279ce549a26473364298067c2b760285eaec1f964423193
-  data.tar.gz: 147a531f6489bc41a102b60b16689c21bc1d852fb18a4d1658115943b35d0d64905d44b81c1ff1d1c4832b5d7739dac4758a436b262c7a6e64aa75db161d92ca
+  metadata.gz: 70819c707de3dfdc0228d238d7b750c48ddba7b6fc23b8f74746ddae1421e88c4dbd5be75a620473af32ae82852aaf4de90eb26927d0efd9ee97b6ecc2588281
+  data.tar.gz: 7c020e3c58a55c65329c25f6503c2669a7ff08f1e86fedde551b8e38a6ba2f3b50042daea0db255ca0adb27bd6e1d19f59bb8f9fe6a250c196d8dbd54634b387

data/CHANGELOG.md

@@ -1,4 +1,20 @@
 ### Unreleased
+- (no changes yet)
+
+### 0.18.0 — 2025-10-28
+- Feature: inequality and nullability operators at leaf level across all adapters:
+  - `neq`, `not_in`, `is_null`, `is_not_null`, `gt`, `gte`, `lt`, `lte`
+- Tests: shared examples added and wired into all adapter-aware suites; full matrix passing.
+- Docs: usage and DSL syntax updated; adapters page notes portability of these operators.
+- Chore: bump version to 0.18.0 and update install snippets to `~> 0.18`.
+
+### 0.17.0 — 2025-10-28
+- Version bump to 0.17.0.
+- Documentation: Updated installation snippets to `~> 0.17`.
+- Documentation: Added comprehensive Range/BETWEEN/MIN/MAX filter docs across README and site (usage, adapters). Clarified sub-key aliases (`between`, `from`/`since`/`after`/`start`/`min`, `to`/`until`/`before`/`end`/`max`), accepted value shapes (Range, 2‑element Array, Hash), nested examples, and equality array semantics (`IN` vs `BETWEEN`).
+- Added Range/BETWEEN/MIN/MAX filters
+
+### 0.16.0 — 2025-10-27
 - Documentation: Added backend auto‑detection feature docs across README and site (index, usage, adapters, configuration). Examples now prefer auto‑detection by default and explain explicit overrides and ambiguity errors.
 - Tests: Added shared examples to exercise auto‑detection behavior under each adapter suite.
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rokaki (0.16.0)
+    rokaki (0.18.0)
       activesupport
 
 GEM

data/README.md

@@ -38,6 +38,25 @@ Docs
 
 Tip: For a dynamic runtime listener (build a filter class from a JSON/hash payload at runtime), see “Dynamic runtime listener” in the Usage docs.
 
+## Range filters (between/min/max)
+
+Use the field name as the key and the filter type as a sub-key, or pass a `Range` directly. Aliases are supported.
+
+```ruby
+# Top-level
+Article.filter(published: { from: Date.new(2024,1,1), to: Date.new(2024,12,31) })
+Article.filter(published: (Date.new(2024,1,1)..Date.new(2024,12,31)))
+
+# Nested
+Article.filter(reviews_published: { max: Time.utc(2024,6,30) })
+```
+
+- Lower bound aliases (>=): `from`, `since`, `after`, `start`, `min`
+- Upper bound aliases (<=): `to`, `until`, `before`, `end`, `max`
+- Arrays always mean `IN (?)` for equality. Use a `Range` or `{ between: [from, to] }` for range filtering
+
+See full docs: https://tevio.github.io/rokaki/usage#range-between-min-and-max-filters
+
 ---
 
 ## Further reading

data/docs/_config.yml

@@ -8,6 +8,14 @@ baseurl: "/rokaki"
 url: "https://tevio.github.io"
 theme: minima
 
+# Limit header navigation to these pages to avoid top-level Oracle link
+header_pages:
+  - index.md
+  - usage.md
+  - dsl_syntax.md
+  - adapters.md
+  - configuration.md
+
 # Build settings
 markdown: kramdown
 kramdown:

data/docs/adapters.md

@@ -22,6 +22,7 @@ Rokaki generates adapter‑aware SQL for PostgreSQL, MySQL, SQL Server, Oracle,
   - Case sensitivity follows DB collation by default; future versions may add inline `COLLATE` options
 - Oracle
   - Uses `LIKE`; arrays of terms are OR‑chained; case‑insensitive paths use `UPPER(column) LIKE UPPER(:q)`
+  - See the dedicated page: [Oracle connections](/rokaki/adapters/oracle) for connection strings, NLS settings, and common errors.
 - SQLite
   - Embedded (no separate server needed)
   - Uses `LIKE`; arrays of terms are OR‑chained across predicates
@@ -78,3 +79,24 @@ database: ":memory:"
 ```
 
 To persist a database file locally, set `SQLITE_DATABASE` to a path (e.g., `tmp/test.sqlite3`).
+
+
+## Inequality and null filters
+
+The following leaf-level operators are adapter-agnostic across PostgreSQL, MySQL, SQL Server, Oracle, and SQLite: `neq`, `not_in`, `is_null`, `is_not_null`, `gt`, `gte`, `lt`, `lte`. Rokaki composes standard SQL (`<>`, `NOT IN`, `IS NULL`/`IS NOT NULL`, `>`, `>=`, `<`, `<=`) with bound parameters.
+
+## Range/BETWEEN filters
+
+Rokaki’s range filters (`between`, lower-bound aliases like `from`/`min`, and upper-bound aliases like `to`/`max`) are adapter‑agnostic. The library always generates parameterized predicates using `BETWEEN`, `>=`, and `<=` on the target column.
+
+Adapter notes:
+- PostgreSQL: Uses regular `WHERE column BETWEEN $1 AND $2` (or `>=`/`<=`). No special handling is required.
+- MySQL/MariaDB: Uses `BETWEEN ? AND ?` (or `>=`/`<=`). Datetime values are compared with the column precision configured by your schema.
+- SQLite: Uses `BETWEEN ? AND ?` (or `>=`/`<=`).
+- SQL Server: Uses `BETWEEN @from AND @to` (or `>=`/`<=`). Parameters are bound via ActiveRecord.
+- Oracle: Uses `BETWEEN :from AND :to` (or `>=`/`<=`). If your column type is `DATE`, be aware it has second precision; `TIMESTAMP` supports fractional seconds.
+
+Tips:
+- For date-only upper bounds (e.g., `2024-12-31`), Rokaki treats them inclusively and, when applicable, will extend to the end of day in basic filters to match expectations. If you need precise control, pass explicit `Time` values.
+- Arrays are treated as equality lists (`IN (?)`) across all adapters. Use a `Range` or `{ between: [from, to] }` for range filtering.
+- `nil` bounds are ignored: only the provided side is applied.

data/docs/dsl_syntax.md

@@ -0,0 +1,204 @@
+---
+layout: page
+title: Rokaki's DSL Syntax
+permalink: /dsl-syntax
+---
+
+This page describes Rokaki’s domain-specific language (DSL) for declaring mappings and how incoming payloads are interpreted, with a focus on the difference between join-structure keys and leaf-level field keys.
+
+The same concepts apply to both DSL entry points:
+- FilterModel (querying a specific ActiveRecord model)
+- Filterable (key mapping only)
+
+See also: Usage, Adapters, and Configuration pages linked from the site index.
+
+## Key ideas
+
+- You declare the shape of your filterable graph in code. This defines which associations (joins) are traversed and which fields are addressable (leaves).
+- At runtime, the payload mirrors only the declared structure. Values at leaves drive the operator semantics (equality, LIKE, range). The structure of joins does not change at runtime.
+
+## Join-structure keys vs leaf-level field keys
+
+- Join-structure keys represent associations. They appear only in the mapping you write (and mirrored by the payload). They do not carry operators by themselves. Examples: `author`, `reviews`, `articles`.
+- Leaf-level field keys represent actual database columns on the current model or on a joined association. Examples: `title`, `content`, `published`, `first_name`.
+- The mapping defines where a key is treated as a join (non-leaf) vs a field (leaf). At a declared leaf, the value can be a scalar, array, range, or an operator-hash (see below). Rokaki will not traverse deeper than the declared leaf.
+
+## Declaring mappings
+
+Two equivalent styles are supported:
+
+### Argument-based form (classic)
+
+```ruby
+class ArticleQuery
+  include Rokaki::FilterModel
+
+  filter_model :article               # Adapter auto-detected; pass db: if needed
+  define_query_key :q                 # Map a single query key to many fields
+
+  like title: :circumfix, content: :circumfix # LIKE mappings (no modes: option)
+
+  # Nested LIKEs and filters via association-shaped hashes
+  like author: { first_name: :prefix, last_name: :suffix }
+
+  # Declare equality/range-capable fields (leafs)
+  filters :published                  # enables :published in payload
+  filters reviews: :published         # enables nested reviews.published
+
+  attr_accessor :filters
+  def initialize(filters: {})
+    @filters = filters
+  end
+end
+```
+
+### Block-form DSL
+
+```ruby
+class ArticleQuery
+  include Rokaki::FilterModel
+
+  filter_model :article
+  define_query_key :q
+
+  filter_map do
+    like title: :circumfix, content: :circumfix
+
+    nested :author do
+      like first_name: :prefix, last_name: :suffix
+      filters :id         # leaf field under author
+    end
+
+    nested :reviews do
+      filters :published  # leaf field under reviews
+    end
+  end
+
+  attr_accessor :filters
+  def initialize(filters: {})
+    @filters = filters
+  end
+end
+```
+
+## Payload rules (what values mean at a leaf)
+
+At a leaf field (e.g., `published` or `reviews.published`):
+
+- Scalar value → equality on the column
+  - Example: `{ published: Time.utc(2024,1,1) }` → `WHERE published = :v`
+
+- Array value → equality `IN` list
+  - Arrays always mean `IN` across adapters.
+  - Example: `{ published: [t1, t2, t3] }` → `WHERE published IN (?, ?, ?)`
+
+- Range (`a..b`) → between
+  - Example: `{ published: (t1..t2) }` → `WHERE published BETWEEN :from AND :to`
+
+- Operator-hash (range-style keys) → between or open-ended bounds
+  - Reserved keys at the leaf indicate operator semantics:
+    - `between`
+    - Lower-bound aliases (>=): `from`, `since`, `after`, `start`, `min`
+    - Upper-bound aliases (<=): `to`, `until`, `before`, `end`, `max`
+  - Examples:
+    - `{ published: { from: t1, to: t2 } }`
+    - `{ published: { between: [t1, t2] } }`
+    - `{ published: { min: t1 } }` → `published >= t1`
+    - `{ published: { max: t2 } }` → `published <= t2`
+
+- Operator-hash (inequality/null) → non-equality predicates
+  - Keys: `neq`, `not_in`, `is_null`, `is_not_null`, `gt`, `gte`, `lt`, `lte`
+  - Examples:
+    - `{ title: { neq: "Draft" } }` → `title <> 'Draft'`
+    - `{ title: { not_in: ["Draft", "Archived"] } }` → `title NOT IN (...)`
+    - `{ content: { is_null: true } }` → `content IS NULL`
+    - `{ published: { gt: t1, lte: t2 } }` → `published > t1 AND published <= t2`
+
+Notes:
+- Only the leaf level interprets these reserved keys. Join-structure keys do not carry operators.
+- Arrays never imply range; to express a range with an array, use `{ published: { between: [from, to] } }`.
+- Nil bounds are ignored: `{ published: { from: t1 } }` applies only the lower bound.
+
+## LIKE mappings and payloads
+
+- You declare LIKE semantics in code via the `like` mapping; the payload provides the terms.
+- Modes:
+  - `:prefix` → `%term`
+  - `:suffix` → `term%`
+  - `:circumfix` (synonyms: `:parafix`, `:confix`, `:ambifix`) → `%term%`
+- Payload values for LIKE can be a string or an array of strings. Arrays are matched with adapter-aware OR semantics.
+
+Examples:
+```ruby
+like title: :circumfix
+like author: { first_name: :prefix }
+
+# Payload examples
+{ q: "First" }
+{ author: { first_name: ["Ada", "Al"] } }
+```
+
+## Nested examples
+
+Top-level field range:
+```ruby
+ArticleQuery.new(filters: { published: { since: Time.utc(2024,1,1), until: Time.utc(2024,6,30) } }).results
+```
+
+Nested association field range:
+```ruby
+ArticleQuery.new(filters: { reviews: { published: (Time.utc(2024,1,1)..Time.utc(2024,6,30)) } }).results
+```
+
+Deep nested example (author → articles → reviews.published):
+```ruby
+class AuthorQuery
+  include Rokaki::FilterModel
+  filter_model :author
+  filter_map do
+    nested :articles do
+      nested :reviews do
+        filters :published
+      end
+    end
+  end
+  attr_accessor :filters
+  def initialize(filters: {}) ; @filters = filters ; end
+end
+
+AuthorQuery.new(filters: { articles: { reviews: { published: { max: Time.utc(2024,6,30) } } } }).results
+```
+
+## Dynamic runtime listener
+
+You can build a filter class at runtime from a payload (see Usage → Dynamic runtime listener). The same rules apply: the mapping fixes the join structure; leaf values drive operators.
+
+```ruby
+payload = {
+  model: :article, db: :postgres, query_key: :q,
+  like: { title: :circumfix, author: { first_name: :prefix } }
+}
+listener = Class.new do
+  include Rokaki::FilterModel
+  filter_model payload[:model], db: payload[:db]
+  define_query_key payload[:query_key]
+  filter_map { like payload[:like] }
+  attr_accessor :filters
+  def initialize(filters: {}) ; @filters = filters ; end
+end
+
+listener.new(filters: { q: "First" }).results
+```
+
+## Adapter behavior
+
+- Range/bounds predicates (`BETWEEN`, `>=`, `<=`) are adapter-agnostic; Rokaki binds parameters appropriately for PostgreSQL, MySQL, SQL Server, Oracle, and SQLite.
+- LIKE behavior is adapter-aware (e.g., Postgres `ANY(ARRAY[..])`, SQL Server `ESCAPE` clause, Oracle `UPPER()` for case-insensitive paths). See the Adapters page for details.
+
+## Quick reference
+
+- Join-structure keys: associations, declared in code, mirrored in payload structure; never carry operators.
+- Leaf-level keys: columns/fields, declared in code with `filters`, accept values that determine semantics.
+- Reserved leaf operator keys: `between`, `from`/`since`/`after`/`start`/`min`, `to`/`until`/`before`/`end`/`max`.
+- Arrays: always equality `IN`.
+- Ranges or operator-hash: range filtering.

data/docs/index.md

@@ -14,6 +14,7 @@ Rokaki is a small Ruby library that helps you build safe, composable filters for
 
 Get started below or jump to:
 - [Usage](./usage)
+- [Rokaki's DSL Syntax](./dsl-syntax)
 - [Database adapters](./adapters)
 - [Configuration](./configuration)
 
@@ -22,7 +23,7 @@ Get started below or jump to:
 Add to your application's Gemfile:
 
 ```ruby
-gem "rokaki", "~> 0.15"
+gem "rokaki", "~> 0.18"
 ```
 
 Then:
@@ -102,13 +103,13 @@ Where `params` can include keys like `q`, `author_first_name`, `author_last_name
 
 All modes accept either a single string or an array of terms.
 
-## What’s new in 0.13.0
+## What’s new in 0.17.0
 
-- Block-form DSL parity across both FilterModel and Filterable
-- Circumfix affix synonyms supported: :parafix, :confix, :ambifix
-- SQL Server adapter support and CI coverage
-- ENV overrides for all adapters in test helpers; improved DB bootstrap in specs
-- Documentation site via GitHub Pages
+- Range filters as first-class filters (non-aggregates): `between`, lower bounds (`from`/`since`/`after`/`start`/`min`), upper bounds (`to`/`until`/`before`/`end`/`max`) on top-level and nested fields.
+- Arrays always mean equality `IN` lists; use a `Range` or `{ between: [from, to] }` to express ranges.
+- Block-form DSL parity across `FilterModel` and `Filterable`, with nested declarations for associations and leaves.
+- Backend auto-detection: adapter inferred from the model connection; pass `db:` only for multi-adapter apps or overrides.
+- Oracle documentation moved under Adapters: see [Database adapters](./adapters) → [Oracle connections](/adapters/oracle).
 
 ## Next steps
 

data/docs/oracle.md

@@ -0,0 +1,138 @@
+---
+layout: page
+title: Oracle connections
+permalink: /adapters/oracle
+---
+
+This page collects Oracle‑specific connection tips for Rokaki (and ActiveRecord in general), including environment variables, client library notes, and how to avoid common errors during local development and CI runs.
+
+Rokaki uses ActiveRecord’s `oracle_enhanced` adapter and ruby‑oci8 under the hood. All examples below assume ActiveRecord 7.1–8.x as used by Rokaki.
+
+## Quick start: commands that work
+
+- Preferred full descriptor (stable across environments):
+
+```bash
+RBENV_VERSION=3.3.0 \
+ORACLE_USERNAME=system ORACLE_PASSWORD=oracle \
+NLS_LANG=AMERICAN_AMERICA.AL32UTF8 \
+ORACLE_DATABASE='(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=127.0.0.1)(PORT=1521))(CONNECT_DATA=(SERVER=DEDICATED)(SERVICE_NAME=FREEPDB1)))' \
+bundle exec rspec spec/lib/04_oracle_aware_spec.rb --format documentation
+```
+
+- EZCONNECT (be sure to include the double slash prefix):
+
+```bash
+RBENV_VERSION=3.3.0 \
+ORACLE_DATABASE=//127.0.0.1:1521/FREEPDB1 \
+ORACLE_USERNAME=system ORACLE_PASSWORD=oracle \
+NLS_LANG=AMERICAN_AMERICA.AL32UTF8 \
+bundle exec rspec spec/lib/04_oracle_aware_spec.rb
+```
+
+Notes:
+- Oracle Free images typically expose a pluggable database (PDB) service named `FREEPDB1`.
+- Oracle XE images typically use `XEPDB1` instead.
+- If you hit listener errors (ORA‑12514/12521), verify the exact service via `lsnrctl status` inside your container and confirm host port mapping.
+
+## Environment variables Rokaki tests understand
+
+The spec helper accepts overrides which are passed to ActiveRecord’s connection config (see `spec/support/database_manager.rb`):
+
+- `ORACLE_HOST` — defaults to `localhost`
+- `ORACLE_PORT` — defaults to `1521`
+- `ORACLE_USERNAME` — database username
+- `ORACLE_PASSWORD` — database password
+- `ORACLE_DATABASE` — EZCONNECT or TNS/descriptor, takes precedence over `ORACLE_SERVICE_NAME`
+- `ORACLE_SERVICE_NAME` — service name (e.g., `FREEPDB1` or `XEPDB1`)
+- `NLS_LANG` — recommended: `AMERICAN_AMERICA.AL32UTF8`
+
+If only `ORACLE_SERVICE_NAME` is provided, Rokaki’s test helper composes a full descriptor automatically. If `ORACLE_DATABASE` is provided, it is used as‑is (recommended for EZCONNECT or explicit descriptors).
+
+## ruby‑oci8 and Instant Client
+
+- Build‑time (already set in this repo’s `.bundle/config`):
+
+```yaml
+BUNDLE_BUILD__RUBY___OCI8: "--with-instant-client-dir=/opt/oracle/instantclient_23_3 \
+  --with-instant-client-include=/opt/oracle/instantclient_23_3/sdk/include \
+  --with-instant-client-lib=/opt/oracle/instantclient_23_3"
+```
+
+- Runtime (set these if the client libraries aren’t found or you see NLS errors):
+
+macOS:
+```bash
+export DYLD_LIBRARY_PATH=/opt/oracle/instantclient_23_3:$DYLD_LIBRARY_PATH
+```
+Linux:
+```bash
+export LD_LIBRARY_PATH=/opt/oracle/instantclient_23_3:$LD_LIBRARY_PATH
+```
+Optional (explicit NLS data path):
+```bash
+export OCI_NLS10=/opt/oracle/instantclient_23_3/nls/data
+```
+
+## Common errors and fixes
+
+- ORA‑12705: Cannot access NLS data files or invalid environment specified
+  - Cause: invalid/missing NLS settings or client libraries not found.
+  - Fix: set `NLS_LANG=AMERICAN_AMERICA.AL32UTF8` (or leave unset), ensure Instant Client libraries are on `DYLD_LIBRARY_PATH` (macOS) or `LD_LIBRARY_PATH` (Linux). Optionally set `OCI_NLS10`.
+
+- ORA‑12514 / ORA‑12521: TNS:listener does not currently know of service requested in connect descriptor / service not registered
+  - Cause: wrong `SERVICE_NAME`, wrong host/port, container not exposing the service.
+  - Fix: run `lsnrctl status` inside the container; use the exact `SERVICE_NAME` (e.g., `FREEPDB1`), confirm host port mapping. For EZCONNECT, remember the `//` prefix: `//HOST:PORT/SERVICE`.
+
+- ORA‑01017: invalid username/password; logon denied
+  - Cause: wrong credentials for the target service/PDB.
+  - Fix: double‑check username/password; for tests you can connect as `SYSTEM` to bootstrap schema, or create a dedicated test user (see below).
+
+## Creating a dedicated test schema user
+
+From `SYSTEM` (connected to the target PDB service):
+
+```sql
+CREATE USER ROKAKI IDENTIFIED BY rokaki;
+GRANT CONNECT, RESOURCE, CREATE TABLE, CREATE SEQUENCE TO ROKAKI;
+ALTER USER ROKAKI QUOTA UNLIMITED ON USERS;
+```
+
+Then connect with:
+
+```bash
+ORACLE_USERNAME=ROKAKI ORACLE_PASSWORD=rokaki \
+ORACLE_DATABASE=//127.0.0.1:1521/FREEPDB1 \
+NLS_LANG=AMERICAN_AMERICA.AL32UTF8 \
+bundle exec rspec spec/lib/04_oracle_aware_spec.rb
+```
+
+## Rails `database.yml` examples
+
+Using `oracle_enhanced` with service name:
+
+```yaml
+production:
+  adapter: oracle_enhanced
+  host: <%= ENV["ORACLE_HOST"] || "localhost" %>
+  port: <%= (ENV["ORACLE_PORT"] || 1521).to_i %>
+  username: <%= ENV["ORACLE_USERNAME"] %>
+  password: <%= ENV["ORACLE_PASSWORD"] %>
+  service_name: <%= ENV["ORACLE_SERVICE_NAME"] || "FREEPDB1" %>
+```
+
+Using EZCONNECT/descriptor directly:
+
+```yaml
+production:
+  adapter: oracle_enhanced
+  username: <%= ENV["ORACLE_USERNAME"] %>
+  password: <%= ENV["ORACLE_PASSWORD"] %>
+  database: <%= ENV["ORACLE_DATABASE"] %> # e.g., //127.0.0.1:1521/FREEPDB1
+```
+
+## CI and local tips
+
+- Prefer the full `(DESCRIPTION=...)` form in CI to avoid resolver quirks.
+- On Oracle Free containers the default service is `FREEPDB1`; on XE it’s `XEPDB1`.
+- If your tests need to create tables, use a user with `CREATE TABLE` and `CREATE SEQUENCE` privileges (our specs do this automatically).

data/docs/usage.md

@@ -5,13 +5,14 @@ permalink: /usage
 ---
 
 This page shows how to use Rokaki to define filters and apply them to ActiveRecord relations.
+For a formal description of the mapping DSL and how payloads are interpreted (join structure vs leaf-level keys), see Rokaki's DSL Syntax: [/dsl-syntax](/dsl-syntax).
 
 ## Installation
 
 Add the gem to your Gemfile and bundle:
 
 ```ruby
-gem "rokaki", "~> 0.15"
+gem "rokaki", "~> 0.18"
 ```
 
 ```bash
@@ -80,6 +81,85 @@ Each accepts a single string or an array of strings. Rokaki generates adapter‑
 - MySQL: `LIKE`/`LIKE BINARY` and, in nested-like contexts, `REGEXP` where designed
 - SQL Server: `LIKE` with safe escaping; arrays expand into OR chains of parameterized `LIKE` predicates
 
+## Range, BETWEEN, MIN, and MAX filters
+
+Rokaki supports range-style filters as normal filters (not aggregates) across all adapters. You don’t have to declare special operators per field — the value shape (and optional sub-keys) drive the behavior.
+
+Preferred syntax: use the field name as the key and the filter type as a sub-key. Aliases are supported.
+
+- Sub-keys:
+  - `between` → interpret the value as a range and generate `BETWEEN`/`>=`/`<=` as appropriate
+  - Lower bound aliases → `>=`: `from`, `since`, `after`, `start`, `min`
+  - Upper bound aliases → `<=`: `to`, `until`, `before`, `end`, `max`
+
+Accepted value shapes for `between` (also works when you pass a range directly as the field value):
+- Ruby `Range`: `1..10`, `Time.utc(2024,1,1)..Time.utc(2024,12,31)`
+- Two-element `Array`: `[from, to]` (only when wrapped with `{ between: [...] }`)
+- Hash with aliases: `{ from:, to: }`, `{ since:, until: }`, `{ after:, before: }`, `{ start:, end: }`
+
+Examples (top-level field):
+
+```ruby
+class ArticleQuery
+  include Rokaki::FilterModel
+  filter_model :article
+
+  # equality filters (existing)
+  filters :author_id, :published
+
+  # LIKEs (existing)
+  define_query_key :q
+  like title: :circumfix
+end
+
+# Between with a Range
+Article.filter(published: Date.new(2024,1,1)..Date.new(2024,12,31))
+
+# Between with a Hash + aliases
+Article.filter(published: { from: Date.new(2024,1,1), to: Date.new(2024,12,31) })
+Article.filter(published: { since: Date.new(2024,1,1), until: Date.new(2024,6,30) })
+
+# Open-ended bounds
+Article.filter(published: { min: Date.new(2024,1,1) })   # >= 2024-01-01
+Article.filter(published: { max: Date.new(2024,12,31) }) # <= 2024-12-31
+
+# Arrays are equality lists (IN), not ranges
+# Use a Range or `{ between: [...] }` for range filtering
+Article.filter(published: [Date.new(2024,5,1), Date.new(2024,12,1)]) # => IN (equality list)
+Article.filter(published: { between: [Date.new(2024,5,1), Date.new(2024,12,1)] })
+```
+
+Nested fields use the same sub-keys and value shapes:
+
+```ruby
+class ArticleQuery
+  include Rokaki::FilterModel
+  filter_model :article
+
+  filter_map do
+    nested :author do
+      # Range filters are value-driven; declaring the field enables the param key
+      filters :created_at   # enables :author_created_at
+    end
+
+    nested :reviews do
+      filters :published    # enables :reviews_published
+    end
+  end
+end
+
+# Params examples
+Article.filter(author_created_at: { from: Time.utc(2024,1,1), to: Time.utc(2024,6,30) })
+Article.filter(reviews_published: (Time.utc(2024,1,1)..Time.utc(2024,6,30)))
+```
+
+Behavior notes:
+- `min`/`max` are interpreted as lower/upper bounds, not aggregate functions.
+- Passing a `Range` directly as the field value is treated as a between filter automatically. Two-element `Array`s are not ranges unless wrapped with `{ between: [...] }`.
+- Arrays with more than two elements are treated as equality lists (`IN (?)`) — use `{ between: [...] }` if you intend a range.
+- `nil` bounds are ignored: only the provided side is applied (e.g., `{ from: t }` becomes `>= t`).
+- All generated predicates are parameterized and adapter‑agnostic (`BETWEEN`, `>=`, `<=`).
+
 ## Nested filters
 
 Use `nested :association` to scope filters to joined tables. Rokaki handles the necessary joins and qualified columns.
@@ -307,3 +387,33 @@ 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.
+
+
+
+## Inequality and null filters
+
+Use leaf-level sub-keys to express non-equality predicates on top-level or nested fields.
+
+- Not equal: `{ field: { neq: value } }` → `<>`
+- Not in: `{ field: { not_in: [v1, v2] } }` → `NOT IN (...)`
+- Nullability:
+  - `{ field: { is_null: true } }` → `IS NULL`
+  - `{ field: { is_not_null: true } }` (or `{ is_null: false }`) → `IS NOT NULL`
+- Explicit comparisons: `{ field: { gt: x, gte: x, lt: x, lte: x } }`
+
+Examples:
+```ruby
+# Top-level
+Article.filter(title:   { neq: "Draft" })
+Article.filter(title:   { not_in: ["Draft", "Archived"] })
+Article.filter(content: { is_null: true })
+Article.filter(published: { gt: Time.utc(2024,1,1) })
+
+# Nested
+Article.filter(author: { first_name: { neq: "Ada" } })
+Article.filter(reviews: { published: { lte: Time.utc(2024,6,1,12) } })
+```
+
+Notes:
+- Arrays remain equality `IN` lists unless used under `not_in`.
+- These predicates are adapter-agnostic and work the same across PostgreSQL, MySQL, SQL Server, Oracle, and SQLite.

data/lib/rokaki/filter_model/basic_filter.rb

@@ -3,13 +3,16 @@
 module Rokaki
   module FilterModel
     class BasicFilter
-      def initialize(keys:, prefix:, infix:, like_semantics:, i_like_semantics:, db:)
+      def initialize(keys:, prefix:, infix:, like_semantics:, i_like_semantics:, db:, between_keys: nil, min_keys: nil, max_keys: nil)
         @keys = keys
         @prefix = prefix
         @infix = infix
         @like_semantics = like_semantics
         @i_like_semantics = i_like_semantics
         @db = db
+        @between_keys = Array(between_keys).compact
+        @min_keys = Array(min_keys).compact
+        @max_keys = Array(max_keys).compact
         @filter_query = nil
       end
       attr_reader :keys, :prefix, :infix, :like_semantics, :i_like_semantics, :db, :filter_query
@@ -83,12 +86,144 @@ module Rokaki
             key: key
           )
         else
-          query = "@model.where(#{key}: #{filter})"
+          # New preferred style: field => { between:/from:/to:/min:/max: }
+          # Also accept direct Range/Array/Hash with from/to aliases.
+          query = <<-RUBY
+            begin
+              _val = #{filter}
+              if _val.is_a?(Hash)
+                # Support wrapper keys like :between as well as bound aliases/min/max
+                _inner = _val
+                if _val.key?(:between) || _val.key?('between')
+                  _inner = _val[:between] || _val['between']
+                end
+                _from = _inner[:from] || _inner['from'] || _inner[:since] || _inner['since'] || _inner[:after] || _inner['after'] || _inner[:start] || _inner['start'] || _inner[:min] || _inner['min']
+                _to   = _inner[:to]   || _inner['to']   || _inner[:until] || _inner['until'] || _inner[:before] || _inner['before'] || _inner[:end]   || _inner['end']   || _inner[:max] || _inner['max']
+
+                if _from.nil? && _to.nil?
+                  # If hash contains range-like but with different container (e.g., { between: range })
+                  if _inner.is_a?(Range)
+                    _from = _inner.begin; _to = _inner.end
+                  elsif _inner.is_a?(Array)
+                    _from, _to = _inner[0], _inner[1]
+                  end
+                end
+
+                # Adjust inclusive end-of-day behavior if upper bound appears to be a date or midnight time
+                if !_to.nil? && (_to.is_a?(Date) && !_to.is_a?(DateTime) || (_to.respond_to?(:hour) && _to.hour == 0 && _to.min == 0 && _to.sec == 0))
+                  _to = (_to.respond_to?(:to_time) ? _to.to_time : _to) + 86399
+                end
+                if !_from.nil? && !_to.nil?
+                  @model.where("#{key} BETWEEN :from AND :to", from: _from, to: _to)
+                elsif !_from.nil?
+                  @model.where("#{key} >= :from", from: _from)
+                elsif !_to.nil?
+                  @model.where("#{key} <= :to", to: _to)
+                else
+                  # Inequality/nullability operators
+                  _op_neq         = _val[:neq] || _val['neq']
+                  _op_not_in      = _val[:not_in] || _val['not_in']
+                  _op_is_null     = _val[:is_null] || _val['is_null']
+                  _op_is_not_null = _val[:is_not_null] || _val['is_not_null']
+                  _op_gt          = _val[:gt] || _val['gt']
+                  _op_gte         = _val[:gte] || _val['gte']
+                  _op_lt          = _val[:lt] || _val['lt']
+                  _op_lte         = _val[:lte] || _val['lte']
+
+                  if !_op_neq.nil?
+                    @model.where("#{key} <> :v", v: _op_neq)
+                  elsif _op_not_in
+                    _arr = Array(_op_not_in)
+                    return @model.none if _arr.empty?
+                    @model.where("#{key} NOT IN (?)", _arr)
+                  elsif _op_is_null == true
+                    @model.where("#{key} IS NULL")
+                  elsif _op_is_not_null == true || _op_is_null == false
+                    @model.where("#{key} IS NOT NULL")
+                  elsif !_op_gt.nil?
+                    @model.where("#{key} > :v", v: _op_gt)
+                  elsif !_op_gte.nil?
+                    @model.where("#{key} >= :v", v: _op_gte)
+                  elsif !_op_lt.nil?
+                    @model.where("#{key} < :v", v: _op_lt)
+                  elsif !_op_lte.nil?
+                    @model.where("#{key} <= :v", v: _op_lte)
+                  else
+                    # Fall back to equality with the original hash
+                    @model.where(#{key}: _val)
+                  end
+                end
+              elsif _val.is_a?(Range)
+                #{build_between_query(filter: filter, key: key)}
+              else
+                # Equality and IN semantics for arrays and scalars (Arrays are always IN lists)
+                @model.where(#{key}: _val)
+              end
+            end
+          RUBY
         end
 
         @filter_query = query
       end
 
+      def build_between_query(filter:, key:)
+        # Accept [from, to], Range, or {from:, to:}
+        # Build appropriate where conditions with bound params
+        <<-RUBY
+          begin
+            _val = #{filter}
+            _from = _to = nil
+            if _val.is_a?(Range)
+              _from = _val.begin
+              _to = _val.end
+            elsif _val.is_a?(Array)
+              _from, _to = _val[0], _val[1]
+            elsif _val.is_a?(Hash)
+              # allow aliases for from/to
+              _from = _val[:from] || _val['from'] || _val[:since] || _val['since'] || _val[:after] || _val['after'] || _val[:start] || _val['start']
+              _to   = _val[:to]   || _val['to']   || _val[:until] || _val['until'] || _val[:before] || _val['before'] || _val[:end]   || _val['end']
+            else
+              # single value → equality
+              return @model.where(#{key}: _val)
+            end
+
+            if !_from.nil? && !_to.nil?
+              @model.where("#{key} BETWEEN :from AND :to", from: _from, to: _to)
+            elsif !_from.nil?
+              @model.where("#{key} >= :from", from: _from)
+            elsif !_to.nil?
+              @model.where("#{key} <= :to", to: _to)
+            else
+              @model
+            end
+          end
+        RUBY
+      end
+
+      def parse_range_semantics(key)
+        k = key.to_s
+        %w[_between _min _max _from _to _after _before _since _until _start _end].each do |suf|
+          if k.end_with?(suf)
+            base = k.sub(/#{Regexp.escape(suf)}\z/, '')
+            op = case suf
+                 when '_between' then :between
+                 when '_min' then :min
+                 when '_max' then :max
+                 when '_from','_after','_since','_start' then :from
+                 when '_to','_before','_until','_end' then :to
+                 else nil
+                 end
+            return [base, op]
+          end
+        end
+        [nil, nil]
+      end
+
+      def build_compare_query(op:, filter:, column:)
+        operator = (op == :'>=') ? '>=' : '<='
+        %Q{@model.where("#{column} #{operator} :v", v: #{filter})}
+      end
+
       # # @model.where('`authors`.`first_name` LIKE BINARY :query', query: "%teev%").or(@model.where('`authors`.`first_name` LIKE BINARY :query', query: "%imi%"))
       # if Array == filter
       #     first_term = filter.unshift

data/lib/rokaki/filter_model/nested_filter.rb

@@ -129,21 +129,17 @@ module Rokaki
           where_after.push(" }")
         end
 
-        joins = joins_before + joins_after
+        joins_arr = joins_before + joins_after
+        joins_str = joins_arr.join
 
         name += "#{leaf}"
-        where_middle = ["{ #{leaf}: #{prefix}#{name} }"]
-
-        where = where_before + where_middle + where_after
-        joins = joins.join
-        where = where.join
 
         if search_mode
           if db == :sqlserver || db == :oracle
             key_leaf = "#{keys.last.to_s.pluralize}.#{leaf}"
             helper = db == :sqlserver ? 'sqlserver_like' : 'oracle_like'
             @filter_methods << "def #{prefix}filter#{infix}#{name};"\
-              "#{helper}(@model.joins(#{joins}), \"#{key_leaf}\", \"#{type}\", #{prefix}#{name}, :#{search_mode}); end;"
+              "#{helper}(@model.joins(#{joins_str}), \"#{key_leaf}\", \"#{type}\", #{prefix}#{name}, :#{search_mode}); end;"
 
             @filter_templates << "@model = #{prefix}filter#{infix}#{name} if #{prefix}#{name};"
           else
@@ -157,14 +153,81 @@ module Rokaki
             )
 
             @filter_methods << "def #{prefix}filter#{infix}#{name};"\
-              "@model.joins(#{joins}).#{query}; end;"
+              "@model.joins(#{joins_str}).#{query}; end;"
 
             @filter_templates << "@model = #{prefix}filter#{infix}#{name} if #{prefix}#{name};"
           end
         else
-          @filter_methods << "def #{prefix}filter#{infix}#{name};"\
-            "@model.joins(#{joins}).where(#{where}); end;"
+          # Preferred: value Hash with sub-keys between/from/to/min/max; also accept Range/Array directly
+          qualified_col = "#{keys.last.to_s.pluralize}.#{leaf}"
+          body = <<-RUBY
+            begin
+              _val = #{prefix}#{name}
+              rel = @model.joins(#{joins_str})
+              if _val.is_a?(Hash)
+                _inner = _val
+                if _val.key?(:between) || _val.key?('between')
+                  _inner = _val[:between] || _val['between']
+                end
+                _from = _inner[:from] || _inner['from'] || _inner[:since] || _inner['since'] || _inner[:after] || _inner['after'] || _inner[:start] || _inner['start'] || _inner[:min] || _inner['min']
+                _to   = _inner[:to]   || _inner['to']   || _inner[:until] || _inner['until'] || _inner[:before] || _inner['before'] || _inner[:end]   || _inner['end']   || _inner[:max] || _inner['max']
+                if _from.nil? && _to.nil?
+                  if _inner.is_a?(Range)
+                    _from = _inner.begin; _to = _inner.end
+                  elsif _inner.is_a?(Array)
+                    _from, _to = _inner[0], _inner[1]
+                  end
+                end
+                if !_from.nil? && !_to.nil?
+                  rel.where("#{qualified_col} BETWEEN :from AND :to", from: _from, to: _to)
+                elsif !_from.nil?
+                  rel.where("#{qualified_col} >= :from", from: _from)
+                elsif !_to.nil?
+                  rel.where("#{qualified_col} <= :to", to: _to)
+                else
+                  # Inequality/nullability operators
+                  _op_neq         = _val[:neq] || _val['neq']
+                  _op_not_in      = _val[:not_in] || _val['not_in']
+                  _op_is_null     = _val[:is_null] || _val['is_null']
+                  _op_is_not_null = _val[:is_not_null] || _val['is_not_null']
+                  _op_gt          = _val[:gt] || _val['gt']
+                  _op_gte         = _val[:gte] || _val['gte']
+                  _op_lt          = _val[:lt] || _val['lt']
+                  _op_lte         = _val[:lte] || _val['lte']
 
+                  if !_op_neq.nil?
+                    rel.where("#{qualified_col} <> :v", v: _op_neq)
+                  elsif _op_not_in
+                    _arr = Array(_op_not_in)
+                    return rel.none if _arr.empty?
+                    rel.where("#{qualified_col} NOT IN (?)", _arr)
+                  elsif _op_is_null == true
+                    rel.where("#{qualified_col} IS NULL")
+                  elsif _op_is_not_null == true || _op_is_null == false
+                    rel.where("#{qualified_col} IS NOT NULL")
+                  elsif !_op_gt.nil?
+                    rel.where("#{qualified_col} > :v", v: _op_gt)
+                  elsif !_op_gte.nil?
+                    rel.where("#{qualified_col} >= :v", v: _op_gte)
+                  elsif !_op_lt.nil?
+                    rel.where("#{qualified_col} < :v", v: _op_lt)
+                  elsif !_op_lte.nil?
+                    rel.where("#{qualified_col} <= :v", v: _op_lte)
+                  else
+                    rel.where("#{qualified_col} = :v", v: _val)
+                  end
+                end
+              elsif _val.is_a?(Range)
+                rel.where("#{qualified_col} BETWEEN :from AND :to", from: _val.begin, to: _val.end)
+              elsif _val.is_a?(Array)
+                # Arrays represent IN semantics for equality; use BETWEEN only when explicitly wrapped via :between
+                rel.where("#{qualified_col} IN (?)", _val)
+              else
+                rel.where("#{qualified_col} = :v", v: _val)
+              end
+            end
+          RUBY
+          @filter_methods << "def #{prefix}filter#{infix}#{name};#{body}; end;"
           @filter_templates << "@model = #{prefix}filter#{infix}#{name} if #{prefix}#{name};"
         end
       end
@@ -182,6 +245,25 @@ module Rokaki
         query
       end
 
+      def parse_range_semantics(key)
+        k = key.to_s
+        %w[_between _min _max _from _to _after _before _since _until _start _end].each do |suf|
+          if k.end_with?(suf)
+            base = k.sub(/#{Regexp.escape(suf)}\z/, '')
+            op = case suf
+                 when '_between' then :between
+                 when '_min' then :from   # min → lower bound
+                 when '_max' then :to     # max → upper bound
+                 when '_from','_after','_since','_start' then :from
+                 when '_to','_before','_until','_end' then :to
+                 else nil
+                 end
+            return [base, op]
+          end
+        end
+        [nil, nil]
+      end
+
     end
   end
 end

data/lib/rokaki/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rokaki
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.18.0
 platform: ruby
 authors:
 - Steve Martin
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-10-27 00:00:00.000000000 Z
+date: 2025-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -296,7 +296,9 @@ files:
 - docs/_config.yml
 - docs/adapters.md
 - docs/configuration.md
+- docs/dsl_syntax.md
 - docs/index.md
+- docs/oracle.md
 - docs/usage.md
 - lib/rokaki.rb
 - lib/rokaki/filter_model.rb