sqlite_crypto 1.0.3 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12ea964ba36c09b8c7e9744815cdc00c5a01faf12f1c7f59d35b8b7f8c2745d8
-  data.tar.gz: f64a0179468f9f080f8cbd73af82cdaaeaa97b32c7dc65bb266332641ea3c602
+  metadata.gz: f7728bff2a398f6ed1fe0ce0888055586b7619d45954728240ef32ba33cd1650
+  data.tar.gz: fb5715411594706283fd93969b4f97709f468870f428105c1cb5ebdefb8d5c56
 SHA512:
-  metadata.gz: c72db90ece738364c5c6474e81adb82a2429b6ec8d41271dadf1666076954ba819c33cbfeacbcc93787cd917aacce5af2b9e381e660f02d348ba8137b3502caf
-  data.tar.gz: 49ea138522ab69884e191d9c6e26ad32831c14b719b2f787271d6183dc9e0f06ae513eb909d89bb460174f8944b2343aeeb45847a7ba95bfb1c0a0557288a15e
+  metadata.gz: 7d0efcd9f607384d1e33ee2c55643408cae5d4a0382885dee40ef6bc0dc142f62d4085cc85f529fd2e76694ffc624651aa7802f85bc0de789716a0b3d7c1aa27
+  data.tar.gz: 9954abb7f5068e1b85f9e636ce1abe0d921baa94b9b7394711745bba9bf349655611dcbd925b6ba0fe1c4d1405f2ae434bf863c7234ed864de17b5748b3efadd

data/CHANGELOG.md

@@ -5,6 +5,49 @@ 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
+- **UUIDv7 Support**: Time-sortable UUIDs with better database index performance
+  - New configuration option: `config.uuid_version = :v7` (default) or `:v4`
+  - Run `rails generate sqlite_crypto:install` to create initializer
+  - UUIDv7 requires Ruby 3.3+ (graceful error on older versions)
+  - `generates_uuid` now respects the configured version
+- **Configuration System**: `SqliteCrypto.configure` block for gem settings
+- **Install Generator**: `rails generate sqlite_crypto:install` creates initializer
+- **Version Detection**: `SqliteCrypto::Generators::Uuid.v7_available?` helper
+
+### Changed
+- **Default UUID version changed to v7** for new projects (better performance)
+- `generates_uuid` now uses centralized generator instead of direct `SecureRandom.uuid`
+
+### Notes
+- **Ruby 3.1/3.2 users**: Set `config.uuid_version = :v4` in initializer
+- No schema changes required - UUIDv4 and v7 are storage-compatible
+- Existing v4 UUIDs work alongside new v7 UUIDs in same table
+
 ## [1.0.3] - 2025-12-30
 
 ### Added

data/README.md

@@ -1,281 +1,206 @@
-# SQLite crypto
+# SQLite Crypto
 
-[![Version](https://img.shields.io/badge/version-1.0.3-blue.svg)](https://github.com/bart-oz/sqlite_crypto/releases)
+[![Version](https://img.shields.io/badge/version-2.0.0-blue.svg)](https://github.com/bart-oz/sqlite_crypto/releases)
 [![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-99.06%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)
 
-Seamless UUID and ULID primary key support for Rails with SQLite3.
+## Overview
 
-### ID Format Comparison
+Seamless UUID and ULID primary key support for Rails applications using SQLite3. Handles type registration, validation, foreign key detection, and schema generation automatically.
 
+```ruby
+create_table :users, id: :uuid do |t|
+  t.string :email
+  t.timestamps
+end
 ```
-INTEGER:  1, 2, 3, ... (sequential, guessable)
-UUID:     550e8400-e29b-41d4-a716-446655440000 (random, 36 chars)
-ULID:     01ARZ3NDEKTSV4RRFFQ69G5FAV (time-sortable, 26 chars)
-```
-
-## Why Use UUID/ULID Instead of Integer IDs?
-
-|  | **Integer** | **UUID** | **ULID** |
-|---|-------------|----------|----------|
-| **Performance** | Baseline | +2-5% slower | +5-10% slower |
-| **Storage** | 8 bytes | 36 bytes (4.5x) | 26 bytes (3.2x) |
-| **Security** | Guessable | Random | Random |
-| **Collisions** | ⚠️ High in distributed systems | Virtually impossible | Virtually impossible |
-| **Sortable** | Sequential | Random | Time-based |
-| **Distributed** | Needs coordination | Generate anywhere | Generate anywhere |
 
-**Performance testing**: Run `bundle exec rspec --tag performance` to benchmark on your hardware. Specs test scaling from 100 → 10,000 records across inserts, queries, updates, and deletes.
+**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
 
-## Gem Compatibility
+## Compatibility
 
-| Ruby Version | Rails 7.1 | Rails 7.2 | Rails 8.0 | Rails 8.1 |
-|--------------|-----------|-----------|-----------|-----------|
-| 3.1          | ✅        | ✅        | ❌        | ❌        |
-| 3.2          | ✅        | ✅        | ✅        | ✅        |
-| 3.3          | ✅        | ✅        | ✅        | ✅        |
-| 3.4          | ✅        | ✅        | ✅        | ✅        |
-| 4.0          | ✅        | ✅        | ✅        | ✅        |
+**Ruby & Rails:**
 
-**Recommended**: Ruby 3.3+ with Rails 8.0+
+|       | 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 | ✓ | ✓ | ✓ | ✓ |
 
-**Support Policy**: Actively maintained with updates for new Ruby and Rails versions.
+**UUID Versions:**
 
-## Features
+| Version | Ruby 3.1/3.2 | Ruby 3.3+ |
+|---------|--------------|-----------|
+| v4 (random) | ✓ | ✓ |
+| v7 (time-ordered) | - | ✓ |
 
-* UUID primary keys with automatic validation
-* ULID primary keys with time-sortable validation
-* Migration DSL helpers (`t.uuid`, `t.ulid`)
-* Automatic foreign key type detection
-* Model extensions for UUID/ULID generation
-* Clean schema.rb output
-* Zero configuration required
+**Database:** SQLite3
 
 ## Installation
 
-Add to your Gemfile:
-
 ```ruby
+# Gemfile
 gem "sqlite_crypto"
 ```
 
-Then run:
-
 ```bash
 bundle install
+rails generate sqlite_crypto:install
 ```
 
-That's it! No generators or configuration needed.
+The generator creates `config/initializers/sqlite_crypto.rb` for configuration.
 
-## Usage
+## Configuration
 
-### UUID Primary Keys
+**1. Configure UUID Version**
 
 ```ruby
-class CreateUsers < ActiveRecord::Migration[8.1]
-  def change
-    create_table :users, id: :uuid do |t|
-      t.string :email
-      t.string :name
-      t.timestamps
-    end
-  end
+# config/initializers/sqlite_crypto.rb
+SqliteCrypto.configure do |config|
+  config.uuid_version = :v7  # or :v4
 end
 ```
 
-### ULID Primary Keys
+The gem automatically selects a default based on your Ruby version (v7 for Ruby 3.3+, v4 otherwise).
+
+**2. Create Tables with UUID/ULID**
 
 ```ruby
-class CreatePosts < ActiveRecord::Migration[8.1]
+class CreateUsers < ActiveRecord::Migration[8.0]
   def change
-    create_table :posts, id: :ulid do |t|
-      t.string :title
-      t.text :content
+    create_table :users, id: :uuid do |t|
+      t.string :email
       t.timestamps
     end
   end
 end
 ```
 
-### UUID/ULID Columns
+**3. Use Your Models**
 
 ```ruby
-class AddTrackingIds < ActiveRecord::Migration[8.1]
-  def change
-    change_table :orders do |t|
-      t.uuid :external_id
-      t.ulid :tracking_number
-    end
-  end
-end
+user = User.create!(email: "test@example.com")
+user.id  # => "018d3f91-8f4a-7000-9e7b-4a5c8d2e1f3a"
 ```
 
-### Foreign Keys (Automatic Detection)
+## Usage
+
+**Primary Keys**
 
-The gem automatically detects UUID/ULID primary keys and creates matching foreign keys:
+Create tables with UUID or ULID primary keys:
 
 ```ruby
-# Users table has UUID primary key
+# UUID
 create_table :users, id: :uuid do |t|
-  t.string :name
+  t.string :email
 end
 
-# Posts automatically get varchar(36) user_id foreign key
-create_table :posts do |t|
-  t.references :user  # Automatically creates varchar(36) foreign key!
+# 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
-# Categories table has ULID primary key
-create_table :categories, id: :ulid do |t|
+create_table :users, id: :uuid do |t|
   t.string :name
 end
 
-# Articles automatically get varchar(26) category_id foreign key
-create_table :articles do |t|
-  t.references :category  # Automatically creates varchar(26) foreign key!
-  t.string :title
-end
-```
-
-### Custom Table Names
-
-Use `:to_table` option for non-standard table names:
-
-```ruby
 create_table :posts do |t|
-  t.references :author, to_table: :users  # Uses users table's UUID type
+  t.references :user  # Automatically varchar(36)
   t.string :title
 end
 ```
 
-### Model Extensions (Auto-Generate UUIDs/ULIDs)
+**Model-Level Generation**
 
-Automatically generate UUID or ULID values for any column:
+Generate UUIDs or ULIDs for any column:
 
 ```ruby
 class User < ApplicationRecord
-  # Generate UUID for 'token' column on create
-  generates_uuid :token
-end
-
-class Order < ApplicationRecord
-  # Generate ULID for 'reference' column with uniqueness validation
-  generates_ulid :reference, unique: true
+  generates_uuid :api_token
+  generates_ulid :tracking_id, unique: true
 end
-```
-
-**Features:**
-- `generates_uuid(attribute, unique: false)` - Generates SecureRandom.uuid
-- `generates_ulid(attribute, unique: false)` - Generates time-sortable ULID
-- `unique: true` - Adds uniqueness validation
-- Preserves existing values (won't overwrite if already set)
-- Works with any string column, not just primary keys
-
-**Example migration:**
 
-```ruby
-class AddTokenToUsers < ActiveRecord::Migration[8.1]
-  def change
-    add_column :users, :token, :string, limit: 36
-    add_index :users, :token, unique: true
-  end
-end
+user = User.create!
+user.api_token    # => "550e8400-e29b-41d4-a716-446655440000"
+user.tracking_id  # => "01ARZ3NDEKTSV4RRFFQ69G5FAV"
 ```
 
-### Schema Output
-
-Your `db/schema.rb` will be clean and readable:
-
-```ruby
-create_table "users", id: :uuid, force: :cascade do |t|
-  t.string "email"
-  t.timestamps
-end
+## ID Types
 
-create_table "posts", force: :cascade do |t|
-  t.string "user_id", limit: 36  # Clean foreign key
-  t.string "title"
-end
-```
+**Characteristics**
 
-## How It Works
+| 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+ |
 
-1. **Type Registration**: Registers `:uuid` and `:ulid` types with ActiveRecord for SQLite3
-2. **Validation**: UUIDs validate 36-char format, ULIDs validate 26-char format
-3. **Migration Helpers**: `t.uuid()` and `t.ulid()` methods in migrations
-4. **Smart References**: `t.references` detects parent table's primary key type
-5. **Model Extensions**: `generates_uuid` and `generates_ulid` for automatic generation
-6. **Schema Dumper**: Outputs clean `id: :uuid` instead of verbose type definitions
+**Performance**
 
-## Requirements
+Benchmarks with 10,000 records on SQLite3:
 
-- Rails 7.1+ (tested on 7.1, 7.2, 8.0, 8.1)
-- Ruby 3.1+
-- SQLite3
+| 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% |
 
-## Migrating Existing Apps
+Run your own: `bundle exec rspec --tag performance`
 
-### New Tables Only (Recommended)
+## Advanced Usage
 
-The safest approach is to use UUID/ULID only for new tables:
+**Non-Standard Table Names**
 
 ```ruby
-# Existing tables keep integer IDs
-# users: id (integer)
-# posts: id (integer), user_id (integer)
-
-# New tables use UUID/ULID
-create_table :invoices, id: :uuid do |t|
-  t.references :user  # Still integer (auto-detected from users table)
-  t.decimal :amount
-end
-
-create_table :sessions, id: :ulid do |t|
-  t.references :user  # Still integer
-  t.string :token
+create_table :posts do |t|
+  t.references :author, to_table: :users
 end
 ```
 
-## Advanced Patterns
-
-### ID Prefixes (Optional)
-
-For Stripe-style prefixed IDs (`inv_`, `usr_`, etc.), add to your models:
+**Mixed ID Types**
 
 ```ruby
-class Invoice < ApplicationRecord
-  before_create :generate_prefixed_id
+create_table :users, id: :uuid do |t|
+  t.string :email
+end
 
-  private
+create_table :sessions, id: :ulid do |t|
+  t.references :user
+end
 
-  def generate_prefixed_id
-    self.id = "inv_#{SecureRandom.uuid}" if id.nil?
-  end
+create_table :logs do |t|  # Integer ID
+  t.text :message
 end
 ```
 
-### Mixing Types
+## Migrating Existing Apps
 
-You can use different primary key types in the same app:
+Add UUID/ULID to new tables while keeping integer IDs on existing tables:
 
 ```ruby
-create_table :users, id: :uuid do |t|
-  t.string :email
-end
-
-create_table :sessions, id: :ulid do |t|
-  t.string :token
-end
-
-create_table :logs do |t|  # Standard integer ID
-  t.string :message
+# Existing tables unchanged
+create_table :invoices, id: :uuid do |t|
+  t.references :user  # Detects integer from users table
+  t.decimal :amount
 end
 ```
 
@@ -289,8 +214,8 @@ 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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SqliteCrypto
+  class Configuration
+    attr_reader :uuid_version
+
+    def initialize
+      # Default to v7 on Ruby 3.3+, v4 on older versions
+      @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/install_generator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/base"
+
+module SqliteCrypto
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates SqliteCrypto initializer for UUID/ULID configuration"
+
+      def create_initializer_file
+        template "initializer.rb.tt", "config/initializers/sqlite_crypto.rb"
+      end
+
+      def display_post_install_message
+        say ""
+        say "SqliteCrypto installed!", :green
+        say ""
+        say "Configuration created at config/initializers/sqlite_crypto.rb"
+        say ""
+        if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.3.0")
+          say "✓ Ruby #{RUBY_VERSION} detected - UUIDv7 is available (default)", :green
+        else
+          say "⚠ Ruby #{RUBY_VERSION} detected - UUIDv7 requires Ruby 3.3+", :yellow
+          say "  Update initializer to use: config.uuid_version = :v4"
+        end
+        say ""
+        say "Next steps:"
+        say "  1. Review config/initializers/sqlite_crypto.rb"
+        say "  2. Use id: :uuid in migrations for UUID primary keys"
+        say ""
+      end
+    end
+  end
+end

data/lib/sqlite_crypto/generators/templates/initializer.rb.tt

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+SqliteCrypto.configure do |config|
+  # UUID generation version: :v4 (random) or :v7 (time-sortable)
+  #
+  # :v7 - Time-sortable UUIDs with better database index performance
+  #       Recommended for new projects. Requires Ruby 3.3+
+  #
+  # :v4 - Random UUIDs, works on all Ruby versions (3.1+)
+  #       Use if you need Ruby 3.1/3.2 compatibility
+  #
+  config.uuid_version = :v7 # UUIDv7 is set as default
+end

data/lib/sqlite_crypto/generators/uuid.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module SqliteCrypto
+  module Generators
+    class Uuid
+      MINIMUM_RUBY_FOR_V7 = Gem::Version.new("3.3.0")
+      V7_AVAILABLE = (Gem::Version.new(RUBY_VERSION) >= MINIMUM_RUBY_FOR_V7)
+
+      class << self
+        def generate(version: SqliteCrypto.config.uuid_version)
+          case version
+          when :v4
+            generate_v4
+          when :v7
+            generate_v7
+          else
+            raise ArgumentError, "Unsupported UUID version: #{version}"
+          end
+        end
+
+        def v7_available?
+          V7_AVAILABLE
+        end
+
+        private
+
+        def generate_v4
+          SecureRandom.uuid
+        end
+
+        def generate_v7
+          if v7_available?
+            SecureRandom.uuid_v7
+          else
+            raise ArgumentError, "UUIDv7 requires Ruby 3.3+. " \
+                                 "Current: Ruby #{RUBY_VERSION}. " \
+                                 "Use config.uuid_version = :v4 or upgrade Ruby."
+          end
+        end
+      end
+    end
+  end
+end

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/model_extensions.rb

@@ -9,7 +9,7 @@ module SqliteCrypto
     module ClassMethods
       def generates_uuid(attribute, unique: false)
         before_create do
-          self[attribute] ||= SecureRandom.uuid
+          self[attribute] ||= SqliteCrypto::Generators::Uuid.generate
         end
 
         validates attribute, uniqueness: true if unique

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 = "1.0.3"
+  VERSION = "2.0.1"
   RUBY_MINIMUM_VERSION = "3.1.0"
   RAILS_MINIMUM_VERSION = "7.1.0"
 end

data/lib/sqlite_crypto.rb

@@ -1,14 +1,25 @@
 # frozen_string_literal: true
 
 require "sqlite_crypto/version"
+require "sqlite_crypto/configuration"
 require "sqlite_crypto/railtie" if defined?(Rails)
 require "sqlite_crypto/schema_dumper" if defined?(ActiveRecord)
 require "sqlite_crypto/schema_definitions"
+require "sqlite_crypto/generators/uuid"
 
 module SqliteCrypto
-  class Error < StandardError; end
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+    alias_method :config, :configuration
 
-  def self.load_extensions
-    # Placeholder for future extension loading logic
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sqlite_crypto
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  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: []
@@ -63,6 +65,10 @@ files:
 - LICENSE.txt
 - README.md
 - lib/sqlite_crypto.rb
+- lib/sqlite_crypto/configuration.rb
+- lib/sqlite_crypto/generators/install_generator.rb
+- lib/sqlite_crypto/generators/templates/initializer.rb.tt
+- lib/sqlite_crypto/generators/uuid.rb
 - lib/sqlite_crypto/migration_helpers.rb
 - lib/sqlite_crypto/model_extensions.rb
 - lib/sqlite_crypto/railtie.rb
@@ -94,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: []