sqlite_crypto 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 628653b7be79d3206b90f05b059a29c2d38912101019bd70355804859e4f9c0a
-  data.tar.gz: dfd43d1ec8f3b34e1326923ca3da3e3137c9f78a3ebe54916726753e47d7e1fc
+  metadata.gz: f7728bff2a398f6ed1fe0ce0888055586b7619d45954728240ef32ba33cd1650
+  data.tar.gz: fb5715411594706283fd93969b4f97709f468870f428105c1cb5ebdefb8d5c56
 SHA512:
-  metadata.gz: 17bdceabe86c7d75a54013a330f9dde6017bb80373e70242831d7fed8880ad7a5c46196fbbf0c9d5b54443a839d359dd1a7fbac690e099e29c13f49e7c2fa548
-  data.tar.gz: 8c67565b5f8644e6d42d1a15e3347ad40006e8c2631222d9d3878697647e4e1c0f7e91f05905528941da569629c1dd0be39eaf3484702b2ae0871fdd93c07f1a
+  metadata.gz: 7d0efcd9f607384d1e33ee2c55643408cae5d4a0382885dee40ef6bc0dc142f62d4085cc85f529fd2e76694ffc624651aa7802f85bc0de789716a0b3d7c1aa27
+  data.tar.gz: 9954abb7f5068e1b85f9e636ce1abe0d921baa94b9b7394711745bba9bf349655611dcbd925b6ba0fe1c4d1405f2ae434bf863c7234ed864de17b5748b3efadd

data/CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.0.1] - 2026-01-14
+
+### Security
+- **CRITICAL:**
+  - Fixed regex anchor vulnerability in UUID/ULID validators
+  - Fixed action_text-trix XSS vulnerability by updating the version to '>= 2.1.16'
+
+### Changed
+- **Eager configuration validation**: Setting `uuid_version = :v7` on Ruby < 3.3 now fails at boot time with clear error message instead of runtime failure
+- **Namespace cleanup**: `uuid` and `ulid` schema helpers now scoped to `ActiveRecord::Schema` instead of global `Object`
+- **Performance**: Cached Ruby version check in `V7_AVAILABLE` constant (eliminates repeated `Gem::Version` comparisons)
+- **Boot time**: Added lazy loading with `ActiveSupport.on_load(:active_record)` hook for faster Rails initialization
+- **Migration performance**: Memoized primary key type detection to avoid redundant database queries
+
+### Removed
+- Unused `SqliteCrypto::Error` class
+- Unused `SqliteCrypto.load_extensions` placeholder method
+
+### Internal
+- Simplified configuration defaults to reuse `Generators::Uuid.v7_available?` logic
+- Improved code organization and removed dead code
+
 ## [2.0.0] - 2026-01-08
 
 ### Added

data/README.md

@@ -4,88 +4,80 @@
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE.txt)
 [![types supported](https://img.shields.io/badge/types-ULID,_UUIDv7/v4-brightgreen.svg)](https://github.com/bart-oz/sqlite_crypto)
 [![Tests](https://img.shields.io/badge/tests-passing-brightgreen.svg)](https://github.com/bart-oz/sqlite_crypto/actions)
-[![Coverage](https://img.shields.io/badge/coverage-98.59%25-brightgreen.svg)](https://github.com/bart-oz/sqlite_crypto/actions)
+[![Coverage](https://img.shields.io/badge/coverage-98.06%25-brightgreen.svg)](https://github.com/bart-oz/sqlite_crypto/actions)
 [![Status](https://img.shields.io/badge/status-active-success.svg)](https://github.com/bart-oz/sqlite_crypto)
 
-**Drop-in UUID and ULID primary keys for Rails + SQLite3**
+## Overview
+
+Seamless UUID and ULID primary key support for Rails applications using SQLite3. Handles type registration, validation, foreign key detection, and schema generation automatically.
 
 ```ruby
-# Just use :uuid or :ulid instead of default integer IDs
 create_table :users, id: :uuid do |t|
   t.string :email
+  t.timestamps
 end
 ```
 
-## What You Get
+**Key capabilities:**
+- UUID primary keys (v4 random or v7 time-ordered)
+- ULID primary keys (time-sortable, compact)
+- Automatic foreign key type detection
+- Model-level ID generation
+- Clean schema.rb output
+- Zero external dependencies
 
-✅ **UUID primary keys** (v4 random or v7 time-sortable)<br/>
-✅ **ULID primary keys** (time-sortable, 26 characters)<br/>
-✅ **Automatic foreign key detection** - `t.references` just works<br/>
-✅ **Model generators** - `generates_uuid :token`<br/>
-✅ **Clean schema.rb** - No verbose type definitions<br/>
-✅ **Zero dependencies** - Uses Ruby's built-in SecureRandom<br/>
+## Compatibility
 
-## Quick Start
+**Ruby & Rails:**
 
-```bash
-bundle add sqlite_crypto
-rails generate sqlite_crypto:install
-```
+|       | Rails 7.1 | Rails 7.2 | Rails 8.0 | Rails 8.1 |
+|-------|-----------|-----------|-----------|-----------|
+| Ruby 3.1 | ✓ | ✓ | - | - |
+| Ruby 3.2 | ✓ | ✓ | ✓ | ✓ |
+| Ruby 3.3 | ✓ | ✓ | ✓ | ✓ |
+| Ruby 3.4 | ✓ | ✓ | ✓ | ✓ |
+| Ruby 4.0 | ✓ | ✓ | ✓ | ✓ |
 
-## ID Type Comparison
+**UUID Versions:**
 
-| Type | Format | Performance | Use Case |
-|------|--------|-------------|----------|
-| **Integer** | `1, 2, 3...` | Baseline | Simple apps, no distribution |
-| **UUIDv7** | `018d3f91-...` (36 chars) | ~1-3% slower inserts | ⭐ **Recommended** - Time-sortable + fast |
-| **UUIDv4** | `550e8400-e29b-...` (36 chars) | ~2-5% slower inserts | Random IDs, legacy compatibility |
-| **ULID** | `01ARZ3NDEK...` (26 chars) | ~3-7% slower inserts | Time-sortable, compact format |
+| Version | Ruby 3.1/3.2 | Ruby 3.3+ |
+|---------|--------------|-----------|
+| v4 (random) | ✓ | ✓ |
+| v7 (time-ordered) | - | ✓ |
 
-### Why UUIDv7 is Recommended
+**Database:** SQLite3
 
-UUIDv7 embeds a timestamp in the first 48 bits, making IDs naturally sortable by creation time:
+## Installation
 
-```
-UUIDv7: 018d3f91-8f4a-7000-9e7b-4a5c8d2e1f3a  ← Time-based (inserts cluster at end)
-UUIDv4: 6ba7b810-9dad-11d1-80b4-00c04fd430c8  ← Random (causes index fragmentation)
+```ruby
+# Gemfile
+gem "sqlite_crypto"
 ```
 
-**Performance Impact:**
-- New records insert at the **end of B-tree index** (not random positions)
-- Reduces page splits and fragmentation
-- ~40% faster index writes vs UUIDv4 at scale (10k+ records)
+```bash
+bundle install
+rails generate sqlite_crypto:install
+```
 
-**Requirements:** Ruby 3.3+ (falls back to v4 on older versions)
+The generator creates `config/initializers/sqlite_crypto.rb` for configuration.
 
 ## Configuration
 
-### Choose UUID Version (v4 or v7)
-
-After running `rails generate sqlite_crypto:install`:
+**1. Configure UUID Version**
 
 ```ruby
 # config/initializers/sqlite_crypto.rb
 SqliteCrypto.configure do |config|
-  config.uuid_version = :v7  # Recommended (requires Ruby 3.3+)
-  # config.uuid_version = :v4  # Use this for Ruby 3.1/3.2
+  config.uuid_version = :v7  # or :v4
 end
 ```
 
-**Ruby Version Support:**
-- Ruby 3.3+ → v4 and v7
-- Ruby 3.1/3.2 → v4 only
+The gem automatically selects a default based on your Ruby version (v7 for Ruby 3.3+, v4 otherwise).
 
-Check programmatically:
-```ruby
-SqliteCrypto::Generators::Uuid.v7_available?  # => true/false
-```
-
-## Usage Examples
-
-### UUID Primary Keys
+**2. Create Tables with UUID/ULID**
 
 ```ruby
-class CreateUsers < ActiveRecord::Migration[8.1]
+class CreateUsers < ActiveRecord::Migration[8.0]
   def change
     create_table :users, id: :uuid do |t|
       t.string :email
@@ -95,106 +87,96 @@ class CreateUsers < ActiveRecord::Migration[8.1]
 end
 ```
 
-Result:
-```ruby
-user = User.create!(email: "alice@example.com")
-user.id  # => "018d3f91-8f4a-7000-9e7b-4a5c8d2e1f3a" (UUIDv7)
-```
-
-### ULID Primary Keys
+**3. Use Your Models**
 
 ```ruby
-class CreatePosts < ActiveRecord::Migration[8.1]
-  def change
-    create_table :posts, id: :ulid do |t|
-      t.string :title
-      t.timestamps
-    end
-  end
-end
+user = User.create!(email: "test@example.com")
+user.id  # => "018d3f91-8f4a-7000-9e7b-4a5c8d2e1f3a"
 ```
 
-Result:
-```ruby
-post = Post.create!(title: "Hello World")
-post.id  # => "01ARZ3NDEKTSV4RRFFQ69G5FAV" (26 chars, time-sortable)
-```
+## Usage
 
-### Automatic Foreign Keys
+**Primary Keys**
 
-The gem **automatically detects** parent table ID types:
+Create tables with UUID or ULID primary keys:
 
 ```ruby
-# Users have UUID primary keys
+# UUID
 create_table :users, id: :uuid do |t|
-  t.string :name
+  t.string :email
 end
 
-# Posts automatically get varchar(36) foreign keys
-create_table :posts do |t|
-  t.references :user      # Auto-detected as varchar(36)!
+# ULID
+create_table :posts, id: :ulid do |t|
   t.string :title
 end
 ```
 
-Works with ULID too:
+**Foreign Keys**
+
+Foreign key types are automatically detected from parent tables:
+
 ```ruby
-create_table :categories, id: :ulid do |t|
+create_table :users, id: :uuid do |t|
   t.string :name
 end
 
-create_table :articles do |t|
-  t.references :category  # Auto-detected as varchar(26)!
+create_table :posts do |t|
+  t.references :user  # Automatically varchar(36)
+  t.string :title
 end
 ```
 
-### Generate UUIDs/ULIDs for Any Column
+**Model-Level Generation**
+
+Generate UUIDs or ULIDs for any column:
 
 ```ruby
 class User < ApplicationRecord
-  generates_uuid :token                    # Auto-generate on create
-  generates_ulid :reference, unique: true  # With uniqueness validation
+  generates_uuid :api_token
+  generates_ulid :tracking_id, unique: true
 end
 
-user = User.create!(email: "test@example.com")
-user.token      # => "018d3f91-..." (auto-generated)
-user.reference  # => "01ARZ3NDEK..." (auto-generated + validated)
+user = User.create!
+user.api_token    # => "550e8400-e29b-41d4-a716-446655440000"
+user.tracking_id  # => "01ARZ3NDEKTSV4RRFFQ69G5FAV"
 ```
 
-## Requirements
+## ID Types
 
-- **Ruby**: 3.1+ (3.3+ for UUIDv7)
-- **Rails**: 7.1, 7.2, 8.0, 8.1
-- **Database**: SQLite3
+**Characteristics**
 
-## Performance Benchmarks
+| Type | Length | Format | Ordering | Ruby Version |
+|------|--------|--------|----------|--------------|
+| Integer | 8 bytes | Sequential numbers | Sequential | Any |
+| UUIDv4 | 36 chars | `xxxxxxxx-xxxx-4xxx-...` | Random | 3.1+ |
+| UUIDv7 | 36 chars | `xxxxxxxx-xxxx-7xxx-...` | Time-based | 3.3+ |
+| ULID | 26 chars | `01ARZ3NDEK...` | Time-based | 3.1+ |
 
-Run your own benchmarks: `bundle exec rspec --tag performance`
+**Performance**
 
-**Typical results (M1 Mac, SQLite3, 10k records):**
+Benchmarks with 10,000 records on SQLite3:
 
-| Operation | Integer (baseline) | UUIDv4 | UUIDv7 | ULID |
-|-----------|-------------------|--------|--------|------|
-| Insert (10k) | 1.00x | 1.02x | 1.01x | 1.05x |
-| Query by ID | 1.00x | 1.03x | 1.03x | 1.04x |
-| Index size | 100% | 145% | 145% | 130% |
+| Type | Insert | Query | Index Size |
+|------|--------|-------|------------|
+| Integer | 1.00x | 1.00x | 100% |
+| UUIDv4 | 1.02x | 1.03x | 145% |
+| UUIDv7 | 1.01x | 1.03x | 145% |
+| ULID | 1.05x | 1.04x | 130% |
 
-**Key takeaway:** UUIDv7 has nearly identical performance to v4, with better write scaling.
-## Advanced Usage
+Run your own: `bundle exec rspec --tag performance`
 
-### Custom Table Names
+## Advanced Usage
 
-Use `:to_table` for non-standard associations:
+**Non-Standard Table Names**
 
 ```ruby
 create_table :posts do |t|
-  t.references :author, to_table: :users  # Uses users table's ID type
+  t.references :author, to_table: :users
 end
 ```
 
-### Mixing ID Types
-
-Different tables can use different ID types:
+**Mixed ID Types**
 
 ```ruby
 create_table :users, id: :uuid do |t|
@@ -202,65 +184,38 @@ create_table :users, id: :uuid do |t|
 end
 
 create_table :sessions, id: :ulid do |t|
-  t.references :user  # Auto-detected as varchar(36)
-end
-
-create_table :logs do |t|  # Integer ID (default)
-  t.string :message
+  t.references :user
 end
-```
-
-### ID Prefixes (Stripe-style)
 
-```ruby
-class Invoice < ApplicationRecord
-  before_create :add_prefix
-
-  private
-  def add_prefix
-    self.id = "inv_#{SecureRandom.uuid}" if id.nil?
-  end
+create_table :logs do |t|  # Integer ID
+  t.text :message
 end
 ```
 
 ## Migrating Existing Apps
 
-Use UUID/ULID only for **new tables**:
+Add UUID/ULID to new tables while keeping integer IDs on existing tables:
 
 ```ruby
-# Keep existing integer IDs
-# users: id (integer)
-# posts: id (integer), user_id (integer)
-
-# New tables use UUID/ULID
+# Existing tables unchanged
 create_table :invoices, id: :uuid do |t|
-  t.references :user  # Still integer (auto-detected)
+  t.references :user  # Detects integer from users table
   t.decimal :amount
 end
 ```
 
-## How It Works
-
-1. **Type Registration** - Registers `:uuid` and `:ulid` with ActiveRecord's SQLite3 adapter
-2. **Validation** - UUIDs: 36-char format, ULIDs: 26-char format
-3. **Migration Helpers** - `t.uuid()` and `t.ulid()` in migrations
-4. **Smart References** - `t.references` detects parent table ID type
-5. **Model Extensions** - `generates_uuid`/`generates_ulid` for auto-generation
-6. **Schema Dumper** - Clean output: `id: :uuid` instead of verbose definitions
-
 ## Development
 
 ```bash
 bundle install
-bundle exec rspec                    # Run tests
-bundle exec standardrb               # Lint
-bundle exec rspec --tag performance  # Benchmarks
+bundle exec rspec
+bundle exec standardrb
 ```
 
 ## Contributing
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+Bug reports and pull requests are welcome on GitHub at https://github.com/bart-oz/sqlite_crypto.
 
 ## License
 
-MIT License - see [LICENSE.txt](LICENSE.txt)
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).

data/lib/sqlite_crypto/configuration.rb

@@ -2,11 +2,31 @@
 
 module SqliteCrypto
   class Configuration
-    attr_accessor :uuid_version
+    attr_reader :uuid_version
 
     def initialize
       # Default to v7 on Ruby 3.3+, v4 on older versions
-      @uuid_version = (Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.3.0")) ? :v7 : :v4
+      @uuid_version = Generators::Uuid.v7_available? ? :v7 : :v4
+    end
+
+    def uuid_version=(version)
+      validate_uuid_version!(version)
+      @uuid_version = version
+    end
+
+    private
+
+    def validate_uuid_version!(version)
+      valid_versions = [:v4, :v7]
+      unless valid_versions.include?(version)
+        raise ArgumentError, "Invalid UUID version: #{version}. Must be one of #{valid_versions.join(", ")}"
+      end
+
+      if version == :v7 && !Generators::Uuid.v7_available?
+        raise ArgumentError,
+          "UUIDv7 requires Ruby 3.3+. Current: #{RUBY_VERSION}. " \
+          "Use config.uuid_version = :v4 or upgrade Ruby."
+      end
     end
   end
 end

data/lib/sqlite_crypto/generators/uuid.rb

@@ -6,7 +6,7 @@ module SqliteCrypto
   module Generators
     class Uuid
       MINIMUM_RUBY_FOR_V7 = Gem::Version.new("3.3.0")
-      CURRENT_RUBY = Gem::Version.new(RUBY_VERSION)
+      V7_AVAILABLE = (Gem::Version.new(RUBY_VERSION) >= MINIMUM_RUBY_FOR_V7)
 
       class << self
         def generate(version: SqliteCrypto.config.uuid_version)
@@ -21,7 +21,7 @@ module SqliteCrypto
         end
 
         def v7_available?
-          CURRENT_RUBY >= MINIMUM_RUBY_FOR_V7
+          V7_AVAILABLE
         end
 
         private

data/lib/sqlite_crypto/migration_helpers.rb

@@ -32,6 +32,11 @@ module SqliteCrypto
       private
 
       def detect_primary_key_type(table_name)
+        @pk_type_cache ||= {}
+        @pk_type_cache[table_name] ||= fetch_primary_key_type(table_name)
+      end
+
+      def fetch_primary_key_type(table_name)
         conn = @conn || @base || (respond_to?(:connection) ? connection : nil)
         return nil unless conn&.table_exists?(table_name)
 

data/lib/sqlite_crypto/railtie.rb

@@ -10,13 +10,17 @@ module SqliteCrypto
     config.sqlite_crypto = ActiveSupport::OrderedOptions.new
 
     initializer "sqlite_crypto.register_types" do
-      ActiveRecord::Type.register(:uuid, SqliteCrypto::Type::Uuid, adapter: :sqlite3)
-      ActiveRecord::Type.register(:ulid, SqliteCrypto::Type::ULID, adapter: :sqlite3)
+      ActiveSupport.on_load(:active_record) do
+        ActiveRecord::Type.register(:uuid, SqliteCrypto::Type::Uuid, adapter: :sqlite3)
+        ActiveRecord::Type.register(:ulid, SqliteCrypto::Type::ULID, adapter: :sqlite3)
+      end
     end
 
     initializer "sqlite_crypto.native_types" do
-      require "active_record/connection_adapters/sqlite3_adapter"
-      ActiveRecord::ConnectionAdapters::SQLite3Adapter.prepend(SqliteCrypto::Sqlite3AdapterExtension)
+      ActiveSupport.on_load(:active_record) do
+        require "active_record/connection_adapters/sqlite3_adapter"
+        ActiveRecord::ConnectionAdapters::SQLite3Adapter.prepend(SqliteCrypto::Sqlite3AdapterExtension)
+      end
     end
 
     initializer "sqlite_crypto.schema_dumper", after: "active_record.initialize_database" do

data/lib/sqlite_crypto/schema_definitions.rb

@@ -13,5 +13,7 @@ module SqliteCrypto
   end
 end
 
-# Extend the main object context for schema.rb loading
-Object.include(SqliteCrypto::SchemaDefinitions)
+# Extend ActiveRecord::Schema context for schema.rb loading (not global Object)
+if defined?(ActiveRecord::Schema)
+  ActiveRecord::Schema.include(SqliteCrypto::SchemaDefinitions)
+end

data/lib/sqlite_crypto/type/ulid.rb

@@ -5,6 +5,8 @@ require "sqlite_crypto/type/base"
 module SqliteCrypto
   module Type
     class ULID < Base
+      ULID_PATTERN = /\A[0-7][0-9A-Z]{25}\z/i
+
       def type
         :ulid
       end
@@ -12,7 +14,7 @@ module SqliteCrypto
       private
 
       def valid?(value)
-        value.match?(/^[0-7][0-9A-Z]{25}$/i)
+        ULID_PATTERN.match?(value)
       end
     end
   end

data/lib/sqlite_crypto/type/uuid.rb

@@ -5,6 +5,8 @@ require "sqlite_crypto/type/base"
 module SqliteCrypto
   module Type
     class Uuid < Base
+      UUID_PATTERN = /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+
       def type
         :uuid
       end
@@ -12,7 +14,7 @@ module SqliteCrypto
       private
 
       def valid?(value)
-        value.match?(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)
+        UUID_PATTERN.match?(value)
       end
     end
   end

data/lib/sqlite_crypto/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module SqliteCrypto
-  VERSION = "2.0.0"
+  VERSION = "2.0.1"
   RUBY_MINIMUM_VERSION = "3.1.0"
   RAILS_MINIMUM_VERSION = "7.1.0"
 end

data/lib/sqlite_crypto.rb

@@ -8,8 +8,6 @@ require "sqlite_crypto/schema_definitions"
 require "sqlite_crypto/generators/uuid"
 
 module SqliteCrypto
-  class Error < StandardError; end
-
   class << self
     def configuration
       @configuration ||= Configuration.new
@@ -24,8 +22,4 @@ module SqliteCrypto
       @configuration = Configuration.new
     end
   end
-
-  def self.load_extensions
-    # Placeholder for future extension loading logic
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sqlite_crypto
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - BartOz
@@ -51,8 +51,10 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-description: A lightweight, modular gem providing transparent UUID/ULID primary key
-  configuration for Rails applications using SQLite.
+description: UUID and ULID primary key support for Rails with SQLite3. Provides automatic
+  type registration, validation, foreign key detection, and clean schema generation.
+  Supports UUIDv4 (random), UUIDv7 (time-ordered), and ULID (compact, time-sortable)
+  with zero external dependencies.
 email:
 - bartek.ozdoba@gmail.com
 executables: []
@@ -98,5 +100,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.3
 specification_version: 4
-summary: Seamless UUID/ULID support for Rails 8 with SQLite
+summary: UUID (v4/v7) and ULID primary keys for Rails + SQLite3
 test_files: []