activerecord-libsql 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91c46e715160345fb5ea4da1089dfcdf14c9f0cdfa57c07d3156487e5a82b5a6
-  data.tar.gz: f1c7cb98472f91cd10d6859a731dcebb1db99c57889f22afd2374ca0a9c535fb
+  metadata.gz: f696c91f955a35679cd2b4159bedc0a9b8429cd30397fe9631054de7f63eb510
+  data.tar.gz: 58df65dd6bfd7aad0a4f187c9935064b4d8d21d57079c44df5f51c765148aca0
 SHA512:
-  metadata.gz: 6f62ea58378238d64192c0e0875d303fc41c96bb1ccfe28f6849ec88f12f0ce3e314bfa3c762d77d69443808e03276f5c9f80400949dfd16e39d5561e4c8310c
-  data.tar.gz: '094e0a7294dc60962b2c826de5cbc0fa3c156f4df2c33da9aaaeda6f38df8844ddb5f9319c6c6219ff7674d10fbad9d20aa3df98e020ff4945b3388b6926c712'
+  metadata.gz: 0a1ec1b42c809eb6cc91516796bdd7ece669396f22415f4940e5a1051780638774948e558aaeefbb22f9837052c86575061ed408ae71b24f018b726d66424ce9
+  data.tar.gz: 8a99cd050bae2dbb898bb74bb798afd7432a943f231efc10685b041ccd98b5a47449ad536f7216be53ed50d9a897bec37fcafd2f7d5f12fe7fd71e77921644ee

data/CHANGELOG.md

@@ -0,0 +1,128 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.1.6] - 2026-03-16
+
+### Fixed
+
+- **`datetime` columns not stored in UTC, breaking `WHERE scheduled_at <= ?` comparisons**
+  - `NATIVE_DATABASE_TYPES` mapped `datetime`/`timestamp` to `'TEXT'`, causing `PRAGMA table_info`
+    to return `TEXT` for those columns. ActiveRecord's type map then resolved them to `Type::Text`,
+    which serializes `Time` objects via `to_s` without UTC normalization.
+  - Changed `datetime` → `'datetime'`, `timestamp` → `'datetime'`, `time` → `'time'`,
+    `date` → `'date'` so that `PRAGMA table_info` returns the correct type name and AR maps
+    them to `Type::DateTime` / `Type::Time` / `Type::Date`.
+  - `Type::DateTime` serializes `Time` objects to UTC strings (e.g. `"2026-03-16 04:18:14"`),
+    making string-based `<=` / `>=` comparisons consistent.
+  - This fixes Solid Queue's Dispatcher, which queries `WHERE scheduled_at <= ?` to find
+    due jobs — the query was always returning empty results when the server timezone was non-UTC.
+  - Added `initialize_type_map` override to explicitly register `datetime`/`timestamp` →
+    `Type::DateTime` as a safety net for existing databases with `TEXT`-typed datetime columns.
+
+- **`cannot commit - no transaction is active` in Hrana HTTP client after fork**
+  - `TursoLibsql::Connection#commit_transaction` now rescues `RuntimeError` containing
+    `"no transaction is active"` or `"cannot commit"`, matching the existing behavior of
+    `LocalConnection` (SQLite3 backend) added in v0.1.4.
+  - Occurs when `ActiveSupport::ForkTracker` triggers `PoolConfig.discard_pools!` after fork,
+    and AR attempts to commit a transaction on the discarded connection before reconnecting.
+
+### Added
+
+- **Solid Queue fork simulation integration tests** (`spec/integration/solid_queue_fork_spec.rb`)
+  - 5 examples reproducing the actual Solid Queue supervisor → worker fork flow.
+  - Verifies that child processes can `INSERT`, call `SolidQueue::Process.create!`,
+    run `FOR UPDATE SKIP LOCKED` queries, and that multiple concurrent workers all succeed.
+  - Verifies that the parent process continues to work after child forks.
+
+## [0.1.5] - 2026-03-13
+
+### Fixed
+
+- **`FOR UPDATE SKIP LOCKED` syntax error with Solid Queue** (#12)
+  - Solid Queue uses `SELECT ... FOR UPDATE SKIP LOCKED` by default (`use_skip_locked: true`).
+    libSQL and SQLite do not support this clause, causing a parse error at the backend.
+  - `LibsqlAdapter#perform_query` now strips `FOR UPDATE` / `FOR UPDATE SKIP LOCKED` / `FOR SHARE`
+    before sending SQL to either the Hrana HTTP API or the local SQLite file.
+  - SQLite serializes all writes, so row-level locking is semantically unnecessary.
+  - Added a regression test that reproduces the exact query Solid Queue's Dispatcher sends.
+
+## [0.1.4] - 2026-03-13
+
+### Fixed
+
+- **Fork safety for Embedded Replica mode** (#9)
+  - `sqlite3` gem 2.x automatically closes SQLite connections after `fork()` (ForkSafety).
+    In Solid Queue, the supervisor forks worker processes. If a transaction was open at fork
+    time, the child process would receive `cannot commit/rollback - no transaction is active`.
+  - `LocalConnection#commit_transaction` and `#rollback_transaction` now rescue
+    `SQLite3::Exception` and silently ignore the "no transaction is active" case.
+  - ActiveRecord's `discard!` already nils `@raw_connection`, so child processes reconnect
+    cleanly on the next query.
+
+### Changed
+
+- Rakefile: removed `rb_sys` / `rake/extensiontask` dependencies (no longer needed after #7).
+  `task default` changed from `:compile` to `:spec`.
+- `rake release` now uses `jj bookmark track` before `jj git push` to avoid the
+  "Refusing to create new remote bookmark" error for new version tags.
+
+## [0.1.3] - 2026-03-13
+
+### Changed
+
+- **Replaced Rust native extension with pure Ruby implementation** (#7)
+  - The original Rust extension used `tokio` + `rustls` (and later `curl` + OpenSSL) for HTTP
+    transport. All Rust TLS implementations are unsafe after `fork()` on macOS, causing SEGV
+    or deadlocks in Puma / Unicorn / Solid Queue multi-process environments.
+  - New implementation uses Ruby's built-in `Net::HTTP` (fork-safe, no native dependencies).
+  - Hrana v2 HTTP protocol is implemented directly in `TursoLibsql::Connection`.
+  - `TursoLibsql::Database` provides a factory for remote, Embedded Replica, and offline modes.
+  - `TursoLibsql.reinitialize_runtime!` is now a no-op (kept for API compatibility).
+  - Added `fork_spec.rb` with 7 integration examples verifying fork safety.
+
+### Added
+
+- `sqlite3 >= 1.4` runtime dependency for Embedded Replica / offline write mode.
+
+### Removed
+
+- Rust extension (`ext/turso_libsql/`), `rb_sys`, and `rake-compiler` dependencies.
+  No `bundle exec rake compile` step is needed anymore.
+
+### Fixed
+
+- `replica_sync`: SQL generation bug — `CREATE TABLE "foo" (...)` was being mangled.
+  Fixed by using `schema.sub(/\ACREATE TABLE\b/i, 'CREATE TABLE IF NOT EXISTS')`.
+- Offline push: `results_as_hash = true` returns Hash rows; use `row.keys` / `row.values`.
+
+## [0.1.2] - 2026-03-12
+
+### Fixed
+
+- `ActiveRecord::Result.empty` compatibility for `affected_rows` (#5).
+  `Result.empty` is a frozen singleton in AR 8; calling `.rows` on it is safe but
+  the adapter was incorrectly reading `affected_row_count` from it.
+- Added Solid Queue integration tests (10 examples) covering `INSERT` into
+  `solid_queue_processes`, `solid_queue_jobs`, and related tables.
+
+## [0.1.1] - 2026-03-12
+
+### Fixed
+
+- `Column.new` signature compatibility across ActiveRecord versions (#4):
+  - AR <= 8.0: `Column.new(name, default, sql_type_metadata, null)`
+  - AR >= 8.1: `Column.new(name, cast_type, default, sql_type_metadata, null)`
+  - Resolved at load time via `COLUMN_BUILDER` lambda to avoid per-call version checks.
+
+## [0.1.0] - 2026-03-10
+
+### Added
+
+- Initial release: ActiveRecord adapter for Turso (libSQL) using a Rust native extension.
+- Remote connection mode via libSQL remote protocol.
+- Embedded Replica mode (`replica_path:`) with optional background sync (`sync_interval:`).
+- Offline write mode (`offline: true`) — writes locally, syncs to remote on `#sync`.
+- `rake turso:schema:apply` and `rake turso:schema:diff` via sqldef (#2).
+- `rake build`, `rake install`, `rake release` tasks (#3).
+- Unit and integration test suite — 57 examples (#1).

data/README.md

@@ -2,12 +2,12 @@
 
 ActiveRecord adapter for [Turso](https://turso.tech) (libSQL) database.
 
-Connects Rails/ActiveRecord models to Turso via a native Rust extension ([magnus](https://github.com/matsadler/magnus) + [libsql](https://github.com/tursodatabase/libsql)), using the libSQL remote protocol directly — no HTTP client wrapper required.
+Connects Rails / ActiveRecord models to Turso Cloud via the **Hrana v2 HTTP protocol**,
+implemented in pure Ruby using `Net::HTTP` — no native extension, no Rust toolchain required.
 
 ## Requirements
 
 - Ruby >= 3.1
-- Rust >= 1.70 (install via [rustup](https://rustup.rs))
 - ActiveRecord >= 7.0
 
 ## Installation
@@ -19,9 +19,10 @@ gem "activerecord-libsql"
 
 ```bash
 bundle install
-bundle exec rake compile
 ```
 
+No compile step needed. The gem is pure Ruby.
+
 ## Configuration
 
 ### database.yml
@@ -39,7 +40,8 @@ production:
   <<: *default
 ```
 
-> **Note**: Use the `database:` key, not `url:`. ActiveRecord tries to resolve the adapter from the URL scheme when `url:` is used, which causes a lookup failure.
+> **Note**: Use the `database:` key, not `url:`. ActiveRecord tries to resolve the adapter
+> from the URL scheme when `url:` is used, which causes a lookup failure.
 
 ### Direct connection
 
@@ -76,7 +78,8 @@ User.find(1).destroy
 
 ## Embedded Replicas
 
-Embedded Replicas keep a local SQLite copy of your Turso database on disk, synced from the remote. Reads are served locally (sub-millisecond), writes go to the remote.
+Embedded Replicas keep a local SQLite copy of your Turso database on disk, synced from the
+remote. Reads are served locally (sub-millisecond), writes go to the remote.
 
 ### Configuration
 
@@ -111,14 +114,46 @@ ActiveRecord::Base.connection.sync
 
 ### Notes
 
-- `replica_path` must point to a clean (empty) file or a previously synced replica. Using an existing SQLite file from another source will cause an error.
+- `replica_path` must point to a writable path. The file is created automatically on first connect.
 - `sync_interval` is in seconds. Set to `0` or omit to use manual sync only.
-- **Multi-process caution**: Do not share the same `replica_path` across multiple Puma workers. Each worker should use a unique path (e.g. `/var/data/myapp-worker-#{worker_id}.db`).
-- The background sync task runs as long as the `Database` object is alive. The adapter holds the `Database` for the lifetime of the connection.
+- **Multi-process (Puma / Solid Queue)**: Each worker process gets its own SQLite connection.
+  `sqlite3` gem 2.x handles fork safety automatically — connections are closed after `fork()`
+  and reopened in the child process. Do not share the same `replica_path` across multiple
+  Puma workers; use a unique path per worker (e.g. `/var/data/myapp-worker-#{worker_id}.db`).
+
+## Solid Queue
+
+This adapter is compatible with [Solid Queue](https://github.com/rails/solid_queue).
+
+### Known behaviour
+
+- **`FOR UPDATE SKIP LOCKED`**: Solid Queue uses this clause by default. libSQL and SQLite
+  do not support it, so the adapter strips it automatically before sending SQL to the backend.
+  SQLite serializes all writes, so row-level locking is not needed.
+- **Fork safety**: Solid Queue forks worker processes. The adapter handles this correctly —
+  `sqlite3` gem 2.x closes connections after `fork()`, and ActiveRecord's `discard!` /
+  `reconnect` flow re-establishes them in the child process.
+
+### Example config
+
+```yaml
+# config/queue.yml
+default: &default
+  dispatchers:
+    - polling_interval: 1
+      batch_size: 500
+  workers:
+    - queues: "*"
+      threads: 3
+      polling_interval: 0.1
+```
 
 ## Schema Management
 
-`turso:schema:apply` and `turso:schema:diff` use [sqldef](https://github.com/sqldef/sqldef) (`sqlite3def`) to manage your Turso schema declaratively — no migration files, no version tracking. You define the desired schema in a `.sql` file and the task computes and applies only the diff.
+`turso:schema:apply` and `turso:schema:diff` use [sqldef](https://github.com/sqldef/sqldef)
+(`sqlite3def`) to manage your Turso schema declaratively — no migration files, no version
+tracking. You define the desired schema in a `.sql` file and the task computes and applies
+only the diff.
 
 ### Prerequisites
 
@@ -129,7 +164,8 @@ brew install sqldef/sqldef/sqlite3def
 # Other platforms: https://github.com/sqldef/sqldef/releases
 ```
 
-`replica_path` must be configured in `database.yml` (the tasks use the local replica to compute the diff without touching the remote directly).
+`replica_path` must be configured in `database.yml` (the tasks use the local replica to
+compute the diff without touching the remote directly).
 
 ### turso:schema:apply
 
@@ -139,31 +175,6 @@ Applies the diff between your desired schema and the current remote schema.
 rake turso:schema:apply[db/schema.sql]
 ```
 
-Example output:
-
-```
-==> [1/4] Pulling latest schema from remote...
-    Done.
-==> [2/4] Computing schema diff...
-    2 statement(s) to apply:
-      ALTER TABLE users ADD COLUMN bio TEXT;
-      CREATE INDEX idx_users_email ON users (email);
-==> [3/4] Applying schema to Turso Cloud...
-    Done.
-==> [4/4] Pulling to confirm...
-    Done.
-==> Schema applied successfully!
-```
-
-If the schema is already up to date:
-
-```
-==> [1/4] Pulling latest schema from remote...
-    Done.
-==> [2/4] Computing schema diff...
-    Already up to date.
-```
-
 ### turso:schema:diff
 
 Shows what would be applied without making any changes (dry-run).
@@ -174,7 +185,8 @@ rake turso:schema:diff[db/schema.sql]
 
 ### schema.sql format
 
-Plain SQL `CREATE TABLE` statements. sqldef handles `ALTER TABLE` / `CREATE INDEX` / `DROP` automatically based on the diff.
+Plain SQL `CREATE TABLE` statements. sqldef handles `ALTER TABLE` / `CREATE INDEX` / `DROP`
+automatically based on the diff.
 
 ```sql
 CREATE TABLE users (
@@ -182,14 +194,6 @@ CREATE TABLE users (
   name TEXT NOT NULL,
   email TEXT NOT NULL
 );
-
-CREATE TABLE posts (
-  id         TEXT PRIMARY KEY,
-  user_id    TEXT NOT NULL,
-  title      TEXT NOT NULL,
-  body       TEXT,
-  created_at TEXT NOT NULL
-);
 ```
 
 ## Architecture
@@ -198,21 +202,36 @@ CREATE TABLE posts (
 Rails Model (ActiveRecord)
   ↓  Arel → SQL string
 LibsqlAdapter  (lib/active_record/connection_adapters/libsql_adapter.rb)
-  ↓  perform_query / exec_update
-TursoLibsql::Database + Connection  (Rust native extension)
-  ↓  libsql::Database / Connection  (async Tokio runtime → block_on)
-
-Remote mode:   Turso Cloud  (libSQL remote protocol over HTTPS)
-Replica mode:  Local SQLite file ←sync→ Turso Cloud
+  ↓  perform_query  (strips FOR UPDATE, expands bind params)
+  ↓
+  ├─ Remote mode ──→ TursoLibsql::Connection  (Hrana v2 HTTP via Net::HTTP)
+  │                       ↓
+  │                  Turso Cloud  (HTTPS)
+  │
+  └─ Embedded Replica / Offline mode
+         ↓
+    TursoLibsql::LocalConnection  (sqlite3 gem)
+         ↓
+    Local SQLite file  ←─ sync ─→  Turso Cloud
 ```
 
+### Why pure Ruby?
+
+The original implementation used a Rust native extension (`tokio` + `rustls`). On macOS,
+all Rust TLS libraries are unsafe after `fork()` — they cause SEGV or deadlocks in
+multi-process servers (Puma, Unicorn, Solid Queue). Ruby's `Net::HTTP` has no such
+restriction and is fully fork-safe.
+
 ## Thread Safety
 
-`libsql::Connection` implements `Send + Sync`, making it thread-safe. ActiveRecord's `ConnectionPool` issues a separate `Adapter` instance per thread, so `@raw_connection` is never shared across threads.
+ActiveRecord's `ConnectionPool` issues a separate `Adapter` instance per thread, so
+`@raw_connection` is never shared across threads. `Net::HTTP` opens a new TCP connection
+per request, which is safe for concurrent use.
 
 ## Performance
 
-Benchmarked against a **Turso cloud database** (remote, over HTTPS) from a MacBook on a home network. All numbers include full round-trip network latency.
+Benchmarked against a **Turso cloud database** (remote, over HTTPS) from a MacBook on a
+home network. All numbers include full round-trip network latency.
 
 | Operation | ops/sec | avg latency |
 |-----------|--------:|------------:|
@@ -224,26 +243,30 @@ Benchmarked against a **Turso cloud database** (remote, over HTTPS) from a MacBo
 | DELETE single row | 6.9 | 145.2 ms |
 | Transaction (10 inserts) | 1.9 | 539.0 ms |
 
-> **Environment**: Ruby 3.4.8 · ActiveRecord 8.1.2 · Turso cloud (remote) · macOS arm64  
+> **Environment**: Ruby 3.4.8 · ActiveRecord 8.1.2 · Turso cloud (remote) · macOS arm64
 > Run `bundle exec ruby bench/benchmark.rb` to reproduce.
 
-Latency is dominated by network round-trips to the Turso cloud endpoint. For lower latency, use [Embedded Replicas](#embedded-replicas) — reads are served from a local SQLite file with sub-millisecond latency.
+Latency is dominated by network round-trips to the Turso cloud endpoint. For lower latency,
+use [Embedded Replicas](#embedded-replicas) — reads are served from a local SQLite file with
+sub-millisecond latency.
 
 ## Feature Support
 
 | Feature | Status |
 |---------|--------|
-| SELECT | ✅ |
-| INSERT | ✅ |
-| UPDATE | ✅ |
-| DELETE | ✅ |
+| SELECT / INSERT / UPDATE / DELETE | ✅ |
 | Transactions | ✅ |
-| Migrations (basic) | ✅ |
+| Migrations (basic DDL) | ✅ |
 | Schema management (sqldef) | ✅ |
-| Prepared statements | ✅ |
-| BLOB | ✅ |
-| NOT NULL / UNIQUE constraint errors → AR exceptions | ✅ |
-| Embedded Replica | ✅ |
+| Bind parameters | ✅ |
+| NOT NULL / UNIQUE / FK constraint → AR exceptions | ✅ |
+| Embedded Replica (local reads) | ✅ |
+| Offline write mode | ✅ |
+| Solid Queue compatibility | ✅ |
+| Fork safety (Puma / Solid Queue) | ✅ |
+| Prepared statements (server-side) | ❌ libSQL HTTP does not support them |
+| EXPLAIN | ❌ |
+| Savepoints | ❌ |
 
 ## Testing
 
@@ -258,7 +281,8 @@ bundle exec rake spec:integration
 bundle exec rake spec:all
 ```
 
-Set `SKIP_INTEGRATION_TESTS=1` to skip integration tests in CI environments without Turso credentials.
+Set `SKIP_INTEGRATION_TESTS=1` to skip integration tests in CI environments without Turso
+credentials.
 
 ## License
 

data/lib/active_record/connection_adapters/libsql_adapter.rb

@@ -19,6 +19,11 @@ module ActiveRecord
       ADAPTER_NAME = 'Turso'
 
       # SQLite 互換の型マッピング（libSQL は SQLite 方言）
+      # datetime / timestamp は 'datetime' を使う。
+      # 'TEXT' にすると PRAGMA table_info が 'TEXT' を返し、
+      # AR の type_map が Type::Text にマッピングしてしまう。
+      # Type::Text は Time を UTC に変換せず文字列化するため、
+      # WHERE scheduled_at <= ? の比較が文字列比較で壊れる。
       NATIVE_DATABASE_TYPES = {
         primary_key: 'INTEGER PRIMARY KEY AUTOINCREMENT',
         string: { name: 'TEXT' },
@@ -26,10 +31,10 @@ module ActiveRecord
         integer: { name: 'INTEGER' },
         float: { name: 'REAL' },
         decimal: { name: 'REAL' },
-        datetime: { name: 'TEXT' },
-        timestamp: { name: 'TEXT' },
-        time: { name: 'TEXT' },
-        date: { name: 'TEXT' },
+        datetime: { name: 'datetime' },
+        timestamp: { name: 'datetime' },
+        time: { name: 'time' },
+        date: { name: 'date' },
         binary: { name: 'BLOB' },
         boolean: { name: 'INTEGER' },
         json: { name: 'TEXT' }
@@ -394,10 +399,15 @@ module ActiveRecord
       def initialize_type_map(m = type_map)
         m.register_type(/^integer/i, Type::Integer.new)
         m.register_type(/^real/i,    Type::Float.new)
-        m.register_type(/^text/i,    Type::String.new)
         m.register_type(/^blob/i,    Type::Binary.new)
         m.register_type(/^boolean/i, Type::Boolean.new)
-        m.register_type(/./,         Type::String.new)
+        # datetime / timestamp は Type::DateTime を使う。
+        # libSQL は datetime を TEXT として保存するが、AR の型キャストで
+        # UTC に正規化してから保存する必要がある（文字列比較の一貫性のため）。
+        register_class_with_precision m, /^datetime/i, Type::DateTime
+        m.alias_type(/^timestamp/i, 'datetime')
+        m.register_type(/^text/i,   Type::String.new)
+        m.register_type(/./,        Type::String.new)
       end
 
       def fetch_type_metadata(sql_type)

data/lib/activerecord/libsql/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   module Libsql
-    VERSION = '0.1.5'
+    VERSION = '0.1.6'
   end
 end

data/lib/turso_libsql/connection.rb

@@ -41,6 +41,10 @@ module TursoLibsql
     end
 
     # トランザクションをコミットする
+    # fork 後に sqlite3 gem の ForkSafety が接続を強制クローズした場合や、
+    # baton が無効になった場合は "cannot commit - no transaction is active" が返る。
+    # AR の discard! → reconnect フローで子プロセスは正常に動作するため、
+    # このエラーは無視して良い。
     def commit_transaction
       requests = [
         { 'type' => 'execute', 'stmt' => { 'sql' => 'COMMIT' } },
@@ -49,6 +53,9 @@ module TursoLibsql
       resp = hrana_pipeline(@baton, requests)
       @baton = nil
       check_errors(resp)
+    rescue RuntimeError => e
+      raise unless e.message.include?('no transaction is active') ||
+                   e.message.include?('cannot commit')
     end
 
     # トランザクションをロールバックする

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-libsql
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - aileron
@@ -89,6 +89,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - README.md
 - activerecord-libsql.gemspec
 - lib/active_record/connection_adapters/libsql_adapter.rb