activerecord-turso 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0c8e05a11274a315a434eb615873a9402e8afd76ff296b8efc030d9bd4d212d9
+  data.tar.gz: 0fa05a0646df999aba45e14fc31a5e2066ad471964d7501fa3994df9882cbca8
+SHA512:
+  metadata.gz: ee153e58a81fb89d2a1578cbbd4841a5720cac7c942916c1c256c234e3c0726f6bc0a2fb500cbcd7733a357efb43b1da37e9a8774a7d2eecfd98561cf9cdda76
+  data.tar.gz: 9d5ec6478407aa7c168c29dfbd64b6dc0661e84fbbb1167041ef8b2615fb5ffab899474787c2ceb946430f2aa92bac8684adaf6ffe2b6cf6188a953eb9ced36b

data/README.md

@@ -0,0 +1,182 @@
+# activerecord-turso
+
+ActiveRecord adapter for [Turso](https://turso.tech) (SQLite compatible).
+
+## Status
+
+This adapter is under active development. It can run basic ActiveRecord operations against Turso today, but several production features are still being hardened. See [Limitations and Risks](#limitations-and-risks) before using it in production.
+
+## Requirements
+
+- Ruby >= 3.0
+- ActiveRecord >= 8.0, < 8.2
+- The `turso` Ruby gem (local bindings at `~/Projects/turso/bindings/ruby` during development)
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "activerecord-turso", path: "~/Projects/activerecord-turso"
+```
+
+Then configure `database.yml`:
+
+```yaml
+development:
+  adapter: turso
+  database: "path/to/db.sqlite3"
+```
+
+For an in-memory database:
+
+```yaml
+test:
+  adapter: turso
+  database: ":memory:"
+```
+
+## Usage
+
+Most standard ActiveRecord operations work the same as with the SQLite3 adapter:
+
+```ruby
+class Post < ActiveRecord::Base
+end
+
+Post.create!(title: "Hello", body: "World", published: true)
+```
+
+### MVCC / BEGIN CONCURRENT
+
+Turso supports `BEGIN CONCURRENT` for optimistic, multi-writer transactions. To opt in, pass `concurrent: true` to `transaction`:
+
+```ruby
+ActiveRecord::Base.transaction(concurrent: true) do
+  user.update!(balance: user.balance - 100)
+  order.create!(amount: 100)
+end
+```
+
+If the commit detects a snapshot conflict, the adapter will automatically retry the block up to a configured limit with exponential backoff.
+
+Configure retry behavior in `database.yml`:
+
+```yaml
+development:
+  adapter: turso
+  database: "path/to/db.sqlite3"
+  turso_mvcc_max_retries: 50
+  turso_mvcc_base_delay_ms: 10
+```
+
+**Important caveats:**
+
+- `transaction(concurrent: true)` requires the same database connection to be held for the entire retry loop. Rails' connection pool may reap the connection between retries, which can silently break MVCC semantics. Use this only when you understand the pooling behavior of your app.
+- `lock!`, `with_lock`, and `lock_version` are not meaningful under MVCC. Do not use them inside concurrent transactions.
+- If the retry limit is exhausted, the conflict is raised as `ActiveRecord::StatementInvalid`. You must handle it in application code.
+
+### Full-text search (Tantivy)
+
+Turso provides full-text search through Tantivy. Use `CREATE INDEX ... USING fts`:
+
+```sql
+CREATE INDEX fts_posts ON posts USING fts (title, body);
+```
+
+From migrations:
+
+```ruby
+class AddFtsToPosts < ActiveRecord::Migration[8.1]
+  def change
+    add_fts_index :posts, [:title, :body], tokenizer: :default
+  end
+end
+```
+
+Query with Tantivy functions:
+
+```sql
+SELECT * FROM posts WHERE fts_match(title, body, 'database');
+```
+
+Note: `fts5` virtual tables are not supported. Use `USING fts` indexes instead.
+
+### Concurrent transactions
+
+Turso supports multi-writer concurrency with MVCC. Enable it in `database.yml`:
+
+```yaml
+development:
+  adapter: turso
+  database: db/dev.sqlite3
+  journal_mode: mvcc
+  busy_timeout: 5000
+```
+
+Use `concurrent: true` inside the same pinned connection:
+
+```ruby
+ActiveRecord::Base.connection.transaction(concurrent: true) do
+  # read-modify-write
+end
+```
+
+Caveats:
+- The connection must stay checked out for the whole transaction; avoid work that yields the ActiveRecord connection back to the pool.
+- `busy_timeout` is used for lock waits, not MVCC snapshot conflicts. Snapshot conflicts retry with bounded backoff.
+
+## Limitations and Risks
+
+The following limitations apply to the current implementation. Read this section carefully before deploying to production.
+
+### 1. Result type metadata uses column declared types
+
+The adapter builds column type maps from `column_decltype` metadata. This works for most column definitions but may not capture type information for computed expressions or subquery columns.
+
+### 2. Batch SQL execution uses a simple string splitter
+
+The adapter's batch execution path splits multi-statement SQL on semicolons. This means SQL containing semicolons inside string literals, triggers, or stored expressions may be split incorrectly. Avoid relying on multi-statement strings other than simple schema dumps.
+
+### 3. MVCC requires opt-in and has pooling caveats
+
+`BEGIN CONCURRENT` is powerful but breaks ActiveRecord's default assumptions:
+
+- ActiveRecord expects transactions to commit unless the database returns an error. With `BEGIN CONCURRENT`, the commit can fail with a snapshot conflict and must be retried.
+- The retry loop must run on the same connection. Rails' connection pool is not MVCC-aware and may return the connection to the pool between retries.
+- Do not combine concurrent transactions with pessimistic locking (`lock!`, `with_lock`, `lock_version`).
+
+Only use `transaction(concurrent: true)` after testing it under your app's concurrency patterns.
+
+### 4. Prepared statement cache is disabled
+
+The adapter returns `false` for `default_prepared_statements` and uses a no-op statement pool. Each query is prepared and finalized individually. This is slower than the upstream SQLite3 adapter for high-volume repeated queries, but avoids correctness issues until the Turso bindings expose stable prepared-statement reuse.
+
+### 5. ActiveRecord 8.0 support is CI-tested, not locally tested
+
+Only ActiveRecord 8.1 is installed in the primary development environment. ActiveRecord 8.0 compatibility is validated through CI. If you run into 8.0-specific issues, please report them.
+
+### 6. Some SQLite-specific features are unsupported or conservatively flagged
+
+- Transaction isolation levels other than the default are reported as unsupported (`supports_transaction_isolation?` returns `false`) because Turso remote connections do not provide shared-cache read-uncommitted semantics.
+- `insert_returning` is enabled only when the reported SQLite version is `>= 3.35.0`.
+- `insert_on_conflict` is enabled only when the reported SQLite version is `>= 3.24.0`.
+
+### 7. `execute_batch` in the underlying bindings is a Ruby-side fallback
+
+The `turso` gem provides `DB#execute_batch` as a convenience that splits and executes statements one by one. It does not use a native batch API, so it carries the same semicolon-splitting risk as item 2 above.
+
+## Development
+
+Run the local test suite:
+
+```bash
+bundle install
+bundle exec rake test
+```
+
+To run against the official Rails Active Record test suite, see the CI workflow in `.github/workflows/test.yml` and the project design doc in `docs/superpowers/specs/`.
+
+## License
+
+MIT

data/lib/active_record/connection_adapters/turso_adapter/connection_management.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class TursoAdapter < SQLite3Adapter
+      module ConnectionManagement
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def new_client(config)
+            db_config = config.symbolize_keys.merge(:timeout => config[:timeout] || 5000)
+            ::Turso::AR::Connection.new(db_config)
+          end
+        end
+
+        def active?
+          @raw_connection && !@raw_connection.closed?
+        rescue ::Turso::Error
+          false
+        end
+
+        def reconnect!(**)
+          @lock.synchronize do
+            disconnect!
+            @raw_connection = self.class.new_client(@config)
+            configure_connection
+          end
+        end
+
+        def disconnect!
+          @lock.synchronize do
+            @raw_connection&.close
+            @raw_connection = nil
+          end
+        end
+
+        def raw_connection
+          @lock.synchronize { @raw_connection }
+        end
+
+        def jdbc?
+          false
+        end
+
+        def configure_connection
+          @mvcc_enabled = false
+
+          if @config[:journal_mode]
+            mode = @config[:journal_mode].to_s
+            execute("PRAGMA journal_mode = #{mode}")
+            if @config[:journal_mode].to_s.downcase == "mvcc"
+              @mvcc_enabled = true
+            end
+          end
+
+          execute("PRAGMA foreign_keys = ON")
+
+          if @config[:timeout] || @config[:busy_timeout]
+            timeout = @config[:busy_timeout] || @config[:timeout]
+            @raw_connection.busy_timeout = timeout
+          end
+
+          if @config[:query_timeout]
+            @raw_connection.query_timeout = @config[:query_timeout]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/turso_adapter/database_statements.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class TursoAdapter < SQLite3Adapter
+      module DatabaseStatements
+        def execute(sql, name = nil)
+          materialize_transactions
+          raw_execute(sql, name)
+        end
+
+        def exec_query(sql, name = "SQL", binds = [], prepare: false)
+          materialize_transactions
+
+          type_casted_binds = type_casted_binds(binds)
+          log(sql, name, binds, type_casted_binds) do
+            with_raw_connection do |conn|
+              stmt = conn.prepare(sql)
+              stmt.bind_positional(type_casted_binds) unless type_casted_binds.empty?
+              result = build_result(stmt)
+              stmt.finalize
+              result
+            end
+          end
+        end
+
+        def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning = nil)
+          if returning && supports_insert_returning?
+            return exec_query(sql, name, binds)
+          end
+
+          materialize_transactions
+
+          type_casted_binds = type_casted_binds(binds)
+          log(sql, name, binds, type_casted_binds) do
+            with_raw_connection do |conn|
+              stmt = conn.prepare(sql)
+              stmt.bind_positional(type_casted_binds) unless type_casted_binds.empty?
+              stmt.execute
+              last_id = pk ? last_inserted_id(sql) : nil
+              stmt.finalize
+              last_id
+            end
+          end
+        end
+
+        def last_inserted_id(sql)
+          @raw_connection.last_insert_rowid
+        end
+
+        def returning_column_values(result)
+          [@raw_connection.last_insert_rowid]
+        end
+
+        def default_timezone
+          ActiveRecord.default_timezone
+        end
+
+        def combine_named_bind_params(binds)
+          binds
+        end
+
+        def select_rows(arel, name = nil)
+          arel = arel_from_relation(arel)
+          sql, binds = to_sql_and_binds(arel)
+          type_casted_binds = type_casted_binds(binds)
+
+          log(sql, name, binds, type_casted_binds) do
+            with_raw_connection do |conn|
+              stmt = conn.prepare(sql)
+              stmt.bind_positional(type_casted_binds) unless type_casted_binds.empty?
+              rows = []
+              while stmt.step == 1
+                rows << stmt.row.to_a
+              end
+              stmt.finalize
+              rows
+            end
+          end
+        end
+
+        def perform_query(raw_connection, sql, binds, type_casted_binds, prepare:, notification_payload:, batch: false)
+          if batch
+            raw_connection.execute_batch(sql)
+            return ActiveRecord::Result.empty(affected_rows: 0)
+          end
+
+          if write_query?(sql)
+            raw_connection.execute(sql, type_casted_binds)
+            affected_rows = raw_connection.changes
+            verified!
+            notification_payload[:affected_rows] = affected_rows
+            notification_payload[:row_count] = 0
+            ActiveRecord::Result.empty(affected_rows: affected_rows)
+          else
+            result = raw_connection.query(sql, type_casted_binds)
+            columns = result.column_names
+            rows = result.map(&:values)
+            affected_rows = raw_connection.changes
+            verified!
+            notification_payload[:affected_rows] = affected_rows
+            notification_payload[:row_count] = rows.length
+            ActiveRecord::Result.new(columns, rows, nil, affected_rows: affected_rows)
+          end
+        end
+
+        def disable_referential_integrity
+          old_foreign_keys = query_value("PRAGMA foreign_keys")
+          old_defer_foreign_keys = query_value("PRAGMA defer_foreign_keys")
+
+          begin
+            execute("PRAGMA defer_foreign_keys = ON")
+            execute("PRAGMA foreign_keys = OFF")
+            yield
+          ensure
+            if old_defer_foreign_keys
+              execute("PRAGMA defer_foreign_keys = #{old_defer_foreign_keys}")
+            end
+            execute("PRAGMA foreign_keys = #{old_foreign_keys}")
+          end
+        end
+
+        private
+
+        def build_result(stmt)
+          columns = (0...stmt.column_count).map { |i| stmt.column_name(i) }
+          type_map = build_type_map(stmt)
+          rows = []
+          while stmt.step == 1
+            rows << stmt.row.to_a
+          end
+          ActiveRecord::Result.new(columns, rows, type_map)
+        end
+
+        def build_type_map(stmt)
+          type_map = {}
+          count = stmt.column_count
+          count.times do |i|
+            decltype = stmt.respond_to?(:column_decltype) ? stmt.column_decltype(i) : nil
+            next unless decltype
+            type_map[i] = decltype_to_type(decltype)
+          end
+          type_map
+        end
+
+        def decltype_to_type(decltype)
+          case decltype.to_s.upcase
+          when /INT/ then Type::Integer.new
+          when /REAL|FLOA|DOUB/ then Type::Float.new
+          when /DEC|NUM/ then Type::Decimal.new
+          when /BOOL/ then Type::Boolean.new
+          when /DATETIME/ then Type::DateTime.new
+          when /DATE/ then Type::Date.new
+          when /JSON/ then Type::Json.new
+          when /BLOB/ then Type::Binary.new
+          else Type::String.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/turso_adapter/error_translation.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class TursoAdapter < SQLite3Adapter
+      module ErrorTranslation
+        def translate_exception(exception, message:, sql:, binds:)
+          cause = exception.cause
+          case cause
+          when ::Turso::ConstraintError
+            translate_constraint_error(message, sql, binds)
+          when ::Turso::NotADatabaseError
+            ActiveRecord::NoDatabaseError.new(message, sql: sql, binds: binds)
+          when ::Turso::BusySnapshotError
+            ActiveRecord::SerializationFailure.new(message, sql: sql, binds: binds)
+          when ::Turso::BusyError
+            ActiveRecord::Deadlocked.new(message, sql: sql, binds: binds)
+          when ::Turso::ReadonlyError
+            ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds)
+          else
+            super
+          end
+        end
+
+        private
+
+        def translate_constraint_error(message, sql, binds)
+          case message
+          when /foreign key constraint/i
+            ActiveRecord::InvalidForeignKey.new(message, sql: sql, binds: binds)
+          when /unique constraint|primary key/i
+            ActiveRecord::RecordNotUnique.new(message, sql: sql, binds: binds)
+          else
+            ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/turso_adapter/schema_statements.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class TursoAdapter < SQLite3Adapter
+      module SchemaStatements
+        def tables(name = nil)
+          query_values(<<~SQL, "SCHEMA")
+            SELECT name FROM sqlite_master
+            WHERE type IN ('table', 'view')
+              AND name NOT LIKE 'sqlite_%'
+              AND name NOT LIKE 'fts_dir_%'
+              AND name NOT LIKE 'sqlite_fts_%'
+          SQL
+        end
+
+        def views
+          query_values(<<~SQL, "SCHEMA")
+            SELECT name FROM sqlite_master WHERE type = 'view'
+          SQL
+        end
+
+        def virtual_tables
+          query_values(<<~SQL, "SCHEMA")
+            SELECT name FROM sqlite_master
+            WHERE type = 'table' AND sql LIKE '%CREATE VIRTUAL TABLE%'
+          SQL
+        end
+
+        def indexes(table_name)
+          super.reject { |idx| idx.name.to_s.start_with?("fts_dir_") || idx.name.to_s.start_with?("sqlite_fts_") }
+        end
+
+        def supports_virtual_tables?
+          true
+        end
+
+        def create_virtual_table(table_name, type_name, columns_or_options = [], **options)
+          type_name = type_name.to_s
+          columns = columns_or_options.is_a?(Array) ? columns_or_options : (columns_or_options[:columns] || [])
+          options = columns_or_options.is_a?(Hash) ? columns_or_options : options
+          options_str = options_to_fts_options(options)
+          execute("CREATE VIRTUAL TABLE #{quote_table_name(table_name)} USING #{type_name} (#{columns.join(", ")})#{options_str}")
+        end
+
+        def drop_virtual_table(table_name, **options)
+          execute("DROP TABLE IF EXISTS #{quote_table_name(table_name)}")
+        end
+
+        def add_fts_index(table_name, columns, tokenizer: :default, weights: {})
+          columns = Array(columns)
+          name = "fts_#{table_name}_#{columns.join('_')}"
+          weights_str = weights.map { |col, w| "#{col}=#{w}" }.join(",")
+          with_clause = ["tokenizer = '#{tokenizer}'"]
+          with_clause << "weights = '#{weights_str}'" unless weights_str.empty?
+
+          execute(<<~SQL)
+            CREATE INDEX #{quote_table_name(name)}
+            ON #{quote_table_name(table_name)} USING fts (#{columns.join(", ")})
+            WITH (#{with_clause.join(", ")})
+          SQL
+        end
+
+        def remove_fts_index(table_name, name = nil)
+          name ||= "fts_#{table_name}"
+          execute("DROP INDEX IF EXISTS #{quote_table_name(name)}")
+        end
+
+        def fts_indexes(table_name)
+          query_values(<<~SQL, "SCHEMA")
+            SELECT name FROM sqlite_master
+            WHERE type = 'index'
+              AND tbl_name = #{quote(table_name)}
+              AND sql LIKE '%USING fts%'
+          SQL
+        end
+
+        private
+
+        def options_to_fts_options(options)
+          return "" if options.empty?
+          " " + options.map { |k, v| "#{k}=#{v}" }.join(", ")
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/turso_adapter/transaction_management.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class TursoAdapter < SQLite3Adapter
+      module TransactionManagement
+        def supports_savepoints?
+          true
+        end
+
+        def begin_db_transaction
+          execute("BEGIN DEFERRED")
+        end
+
+        def commit_db_transaction
+          execute("COMMIT TRANSACTION")
+        end
+
+        def rollback_db_transaction
+          execute("ROLLBACK TRANSACTION")
+        end
+
+        def create_savepoint(name = current_savepoint_name(true))
+          execute("SAVEPOINT #{savepoint_name(name)}")
+        end
+
+        def rollback_to_savepoint(name = current_savepoint_name(true))
+          execute("ROLLBACK TO SAVEPOINT #{savepoint_name(name)}")
+        end
+
+        def release_savepoint(name = current_savepoint_name(true))
+          execute("RELEASE SAVEPOINT #{savepoint_name(name)}")
+        end
+
+        def transaction(requires_new: nil, isolation: nil, joinable: true, **options, &block)
+          if options.delete(:concurrent)
+            transaction_with_mvcc(options, &block)
+          else
+            super
+          end
+        end
+
+        private
+
+        def transaction_with_mvcc(options, &block)
+          unless @mvcc_enabled
+            raise ActiveRecord::AdapterError,
+                  "transaction(concurrent: true) requires journal_mode: 'mvcc' in database.yml"
+          end
+
+          max_retries = @config.fetch(:concurrent_retry_limit, 50)
+          base_delay_ms = @config.fetch(:concurrent_retry_base_ms, 2)
+          retries = 0
+
+          loop do
+            begin
+              raw_execute("BEGIN CONCURRENT", "TRANSACTION")
+              yield
+              raw_execute("COMMIT", "TRANSACTION")
+              return
+            rescue ActiveRecord::StatementInvalid => e
+              raw_execute("ROLLBACK", "TRANSACTION") rescue nil
+              raise unless concurrent_conflict?(e) && retries < max_retries
+
+              retries += 1
+              sleep(base_delay_ms * retries / 1000.0)
+            end
+          end
+        end
+
+        def concurrent_conflict?(exception)
+          exception.cause.is_a?(::Turso::BusySnapshotError) ||
+            exception.cause.is_a?(::Turso::BusyError) ||
+            /snapshot conflict|busy snapshot|database is locked/i.match?(exception.message)
+        end
+
+        def savepoint_name(name)
+          "#{name}_sp"
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/turso_adapter.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "active_record/connection_adapters/sqlite3_adapter"
+
+Dir[File.expand_path("turso_adapter/*.rb", __dir__)].each { |f| require f }
+
+module ActiveRecord
+  module ConnectionAdapters
+    class TursoAdapter < SQLite3Adapter
+      include ConnectionManagement
+      include DatabaseStatements
+      include TransactionManagement
+      include SchemaStatements
+      include ErrorTranslation
+
+      ADAPTER_NAME = "Turso"
+
+      def supports_ddl_transactions?
+        true
+      end
+
+      def supports_insert_returning?
+        false
+      end
+
+      def supports_transaction_isolation?
+        false
+      end
+
+      def supports_check_constraint?
+        true
+      end
+
+      def supports_explain?
+        true
+      end
+
+      def explain(arel, binds = [])
+        sql = "EXPLAIN QUERY PLAN " + to_sql(arel, binds)
+        result = exec_query(sql, "EXPLAIN", binds)
+        SQLite3::ExplainPrettyPrinter.new.pp(result)
+      end
+
+      def default_prepared_statements
+        false
+      end
+
+      def database_file_exists?
+        File.exist?(@config[:database])
+      end
+
+      def connect
+        @raw_connection = self.class.new_client(@connection_parameters)
+        configure_connection
+      rescue ::Turso::Error => e
+        raise ActiveRecord::ConnectionNotEstablished, e.message
+      end
+
+      def check_version
+        true
+      end
+
+      def encoding
+        "UTF-8"
+      end
+
+      private
+
+      def initialize_type_map(m)
+        super
+        m.register_type(%r(boolean)i, Type::Boolean.new)
+      end
+    end
+  end
+end

data/lib/activerecord-turso.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "turso"
+
+require_relative "turso/ar/connection"
+require_relative "active_record/connection_adapters/turso_adapter"
+
+ActiveRecord::ConnectionAdapters.register(
+  "turso",
+  "ActiveRecord::ConnectionAdapters::TursoAdapter",
+  "active_record/connection_adapters/turso_adapter"
+)

data/lib/turso/ar/connection.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Turso
+  module AR
+    class Connection
+      extend Forwardable
+
+      def_delegators :@db, :close, :closed?, :changes, :total_changes
+
+      def initialize(config)
+        @config = config
+        @db = ::Turso::DB.new(config[:database].to_s,
+          busy_timeout: config[:busy_timeout] || config[:timeout],
+          query_timeout: config[:query_timeout])
+      end
+
+      def last_insert_rowid
+        query("SELECT last_insert_rowid()").first&.values&.first.to_i
+      end
+
+      def raw_connection
+        @db
+      end
+
+      def open?
+        !@db.closed?
+      end
+
+      def disconnect!
+        @db.close unless @db.closed?
+      end
+
+      def execute(sql, binds = [])
+        @db.execute(sql, normalize_binds(binds))
+        nil
+      end
+
+      def query(sql, params = [])
+        @db.query(sql, normalize_binds(params))
+      end
+
+      def execute_batch(sql)
+        sql.split(";").each do |stmt|
+          s = stmt.strip
+          @db.execute(s) unless s.empty?
+        end
+      end
+
+      def prepare(sql)
+        @db.instance_variable_get(:@database).connection.prepare(sql)
+      end
+
+      def busy_timeout=(ms)
+        @db.busy_timeout = ms.to_i
+      end
+
+      def query_timeout=(ms)
+        @db.query_timeout = ms.to_i
+      end
+
+      def interrupt
+        @db.interrupt
+      end
+
+      private
+
+      def normalize_binds(binds)
+        binds.map do |value|
+          case value
+          when true then 1
+          when false then 0
+          else value
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-turso
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ben D'Angelo
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.2'
+- !ruby/object:Gem::Dependency
+  name: turso
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/active_record/connection_adapters/turso_adapter.rb
+- lib/active_record/connection_adapters/turso_adapter/connection_management.rb
+- lib/active_record/connection_adapters/turso_adapter/database_statements.rb
+- lib/active_record/connection_adapters/turso_adapter/error_translation.rb
+- lib/active_record/connection_adapters/turso_adapter/schema_statements.rb
+- lib/active_record/connection_adapters/turso_adapter/transaction_management.rb
+- lib/activerecord-turso.rb
+- lib/turso/ar/connection.rb
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.15
+specification_version: 4
+summary: ActiveRecord adapter for Turso
+test_files: []