activerecord-sqlite-types 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81175508913f3b2ce7a13f10d48dd86bfa7c040bd77945af0c1b14c95468847d
-  data.tar.gz: 01fe17d2fbc47bde9745418246959cfe376e1a454bd6448b723ec2a2f09b5974
+  metadata.gz: 3b2ce466647cec30a5ddb1f87e7f2721fad43f8a8de5eeeba8bf19172ef8386a
+  data.tar.gz: fb6289b9981c9e0e79ef4db08aa8436906310b4c0a8849dba8406176a31064f5
 SHA512:
-  metadata.gz: be09ffdd30ac8794d139836d669a2f410caad99abf4e247b95684876c767a413e769840953cd8d13cdfd09a318f5b46e055830a87b9b46780a1d636a22a8eebc
-  data.tar.gz: 64b75feb538d840a567201e486e4685a9fbf0483e9fa9cc514a2f75bad8a2677a15386dadf8163d2fe999f3779506059d64c2a39ad76ba99b5c0aa9059262f3f
+  metadata.gz: 417f05eb69a1df1a10effc7af883c3beb2130248fd94c23f7bc628323d195e09bb8072e9ad27d7eb34e7a737ce0c9e5b809af649c5c356e58ef753388a871186
+  data.tar.gz: 02b49246f0ecb7ee52c17de2392710f6e99a6ed3e3f4cc7966c396ea44b29bb9487795f027291d5d19b89d7aba7d4aff90f76fc4da2d3b5e3ea361500634bca8

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [0.4.0] - 2026-05-15
+
+### Added
+
+- Add SQLite JSON-backed array column query scopes for containment, overlap, and negated matches
+
 ## [0.3.3] - 2026-05-14
 
 ### Fixed

data/README.md

@@ -115,7 +115,35 @@ end
 
 **Querying arrays:**
 
-For array querying functionality, see [Stephen Margheim's article on enhancing Rails SQLite array columns](https://fractaledmind.github.io/2023/09/12/enhancing-rails-sqlite-array-columns/).
+Include `SQLiteTypes::ArrayColumns` in models where you want tag-style querying helpers for JSON-backed array columns:
+
+```ruby
+class Event < ApplicationRecord
+  include SQLiteTypes::ArrayColumns
+
+  attribute :relationship_statuses, SQLiteTypes::Array.new(:string)
+  array_columns :relationship_statuses
+end
+```
+
+Declaring an array column adds sanitization before validation, class aggregate methods, scopes, and instance predicates:
+
+```ruby
+Event.unique_relationship_statuses
+Event.relationship_statuses_cloud
+Event.with_relationship_statuses
+Event.without_relationship_statuses
+Event.with_any_relationship_statuses("single", "partnered")
+Event.with_all_relationship_statuses("single", "partnered")
+Event.without_any_relationship_statuses("single")
+Event.without_all_relationship_statuses("single", "partnered")
+
+event.has_any_relationship_statuses?("single", "partnered")
+event.has_all_relationship_statuses?("single", "partnered")
+event.has_relationship_status?("single")
+```
+
+Values are compacted, stringified, deduplicated, and sorted before validation and query comparison. The scopes use SQLite's `JSON_EACH` function and are based on [Stephen Margheim's article on enhancing Rails SQLite array columns](https://fractaledmind.com/2023/09/12/enhancing-rails-sqlite-array-columns/).
 
 ### Interval
 

data/lib/activerecord-sqlite-types.rb

@@ -1,10 +1,13 @@
 require "active_record"
+require "active_support/concern"
+require "active_support/core_ext/object/blank"
 require "active_support/time"
 require "date"
 require "ipaddr"
 require_relative "sqlite_types/version"
 require_relative "sqlite_types/ip_address"
 require_relative "sqlite_types/array"
+require_relative "sqlite_types/array_columns"
 require_relative "sqlite_types/interval"
 require_relative "sqlite_types/migration_helpers"
 

data/lib/sqlite_types/array.rb

@@ -92,10 +92,11 @@ module SQLiteTypes
         elem
       when :hash
         return elem if json_compatible?(elem)
-        return json_round_trip(elem) if elem.is_a?(::Hash)
 
         serialized = json_round_trip(elem)
-        raise ArgumentError, "Invalid #{@subtype} array element: #{elem.inspect}" unless serialized.is_a?(::Hash) && serialized.any?
+        unless serialized.is_a?(::Hash) && serialized.any?
+          raise ArgumentError, "Invalid #{@subtype} array element: #{elem.inspect}"
+        end
 
         serialized
       when :json, :jsonb
@@ -204,7 +205,7 @@ module SQLiteTypes
     end
 
     def json_round_trip(value)
-      ::ActiveSupport::JSON.decode(::ActiveSupport::JSON.encode(value))
+      ActiveSupport::JSON.decode(ActiveSupport::JSON.encode(value))
     rescue JSON::ParserError, TypeError, EncodingError
       raise ArgumentError, "Invalid #{@subtype} array element: #{value.inspect}"
     end

data/lib/sqlite_types/array_columns.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module SQLiteTypes
+  module ArrayColumns
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def array_columns_sanitize_list(values = [])
+        return [] if values.nil?
+
+        values.select(&:present?).map(&:to_s).uniq.sort
+      end
+
+      def array_columns(*column_names)
+        @array_columns ||= {}
+
+        array_columns_sanitize_list(column_names).each do |column_name|
+          @array_columns[column_name] ||= false
+        end
+
+        @array_columns.each do |column_name, initialized|
+          next if initialized
+
+          define_array_column_methods(column_name)
+          @array_columns[column_name] = true
+        end
+      end
+
+      private
+
+      def define_array_column_methods(column_name)
+        method_name = column_name.downcase
+        json_each = Arel::Nodes::NamedFunction.new("JSON_EACH", [arel_table[column_name]])
+
+        define_array_column_aggregate_methods(method_name, json_each)
+        define_array_column_presence_scopes(method_name, column_name)
+        define_array_column_query_scopes(method_name, json_each)
+        define_array_column_predicates(method_name, column_name)
+        define_array_column_writer(column_name)
+
+        before_validation -> { self[column_name] = self.class.array_columns_sanitize_list(self[column_name]) }
+      end
+
+      def define_array_column_aggregate_methods(method_name, json_each)
+        define_singleton_method :"unique_#{method_name}" do |_conditions = "true"|
+          select("value")
+            .from([arel_table, json_each])
+            .distinct
+            .pluck("value")
+            .sort
+        end
+
+        define_singleton_method :"#{method_name}_cloud" do |_conditions = "true"|
+          select("value")
+            .from([arel_table, json_each])
+            .group("value")
+            .order("value")
+            .pluck(Arel.sql("value, COUNT(*) AS count"))
+            .to_h
+        end
+      end
+
+      def define_array_column_presence_scopes(method_name, column_name)
+        scope :"with_#{method_name}", -> {
+          where.not(arel_table[column_name].eq(nil))
+            .where.not(arel_table[column_name].eq([]))
+        }
+
+        scope :"without_#{method_name}", -> {
+          where(arel_table[column_name].eq(nil))
+            .or(where(arel_table[column_name].eq([])))
+        }
+      end
+
+      def define_array_column_query_scopes(method_name, json_each)
+        overlap_query = ->(items) {
+          values = array_columns_sanitize_list(items)
+
+          Arel::SelectManager.new(json_each)
+            .project(1)
+            .where(Arel.sql("CAST(value AS TEXT)").in(values))
+            .take(1)
+            .exists
+        }
+
+        contains_query = ->(items) {
+          values = array_columns_sanitize_list(items)
+          count = Arel::SelectManager.new(json_each)
+            .project(Arel.sql("value").count(true))
+            .where(Arel.sql("CAST(value AS TEXT)").in(values))
+
+          Arel::Nodes::Equality.new(count, values.size)
+        }
+
+        scope :"with_any_#{method_name}", ->(*items) {
+          where overlap_query.call(items)
+        }
+
+        scope :"with_all_#{method_name}", ->(*items) {
+          where contains_query.call(items)
+        }
+
+        scope :"without_any_#{method_name}", ->(*items) {
+          where.not overlap_query.call(items)
+        }
+
+        scope :"without_all_#{method_name}", ->(*items) {
+          where.not contains_query.call(items)
+        }
+      end
+
+      def define_array_column_writer(column_name)
+        define_method :"#{column_name}=" do |value|
+          super(self.class.array_columns_sanitize_list(value))
+        end
+      end
+
+      def define_array_column_predicates(method_name, column_name)
+        define_method :"has_any_#{method_name}?" do |*values|
+          values = self.class.array_columns_sanitize_list(values)
+          existing = self.class.array_columns_sanitize_list(self[column_name])
+
+          (values & existing).present?
+        end
+
+        define_method :"has_all_#{method_name}?" do |*values|
+          values = self.class.array_columns_sanitize_list(values)
+          existing = self.class.array_columns_sanitize_list(self[column_name])
+
+          (values & existing).size == values.size
+        end
+
+        alias_method :"has_#{method_name.singularize}?", :"has_all_#{method_name}?"
+      end
+    end
+  end
+end

data/lib/sqlite_types/version.rb

@@ -1,3 +1,3 @@
 module SQLiteTypes
-  VERSION = "0.3.3"
+  VERSION = "0.4.0"
 end

data/sig/sqlite_types.rbs

@@ -16,6 +16,9 @@ module SQLiteTypes
     def force_equality?: (untyped value) -> bool
   end
 
+  module ArrayColumns
+  end
+
   class Interval < ActiveRecord::Type::Value
     def serialize: (untyped value) -> untyped
     def type_cast_for_schema: (untyped value) -> String

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-sqlite-types
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Wojtek Wrona
@@ -83,6 +83,7 @@ files:
 - lib/generators/sqlite_types/migration/templates/migration.rb.tt
 - lib/sqlite_types.rb
 - lib/sqlite_types/array.rb
+- lib/sqlite_types/array_columns.rb
 - lib/sqlite_types/interval.rb
 - lib/sqlite_types/ip_address.rb
 - lib/sqlite_types/migration_helpers.rb