activerecord-libsql 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a2e0290b309de0e7c29a936ede00a24b7aef1b6c79a648eb2ff5e593b5ee973
-  data.tar.gz: d4b0be5e49b7a3b52bee275016a9dd7145346404691d5918079193b5e44e4cd7
+  metadata.gz: bc66869ba4dd6395bcac2e61abbef9e58dc7bb87f7fc23029aa19f2e5a2419b4
+  data.tar.gz: 5a4feeb7234a157cec8b3f8f2be015d24f5163581e42dc5c501b844830e4b704
 SHA512:
-  metadata.gz: e7d1a814f4be1669eb69a31df52aa316f66e200ad014c7ced335b71cfddf377e782da639cfa709eac01cccaae9b8ff4366ee153394288476d28447920a977b06
-  data.tar.gz: bde5a707c097e7f35b71ab8a49d720402829b6f869812886d47dbd00912ca7407a7bcb833a4d635f564df8903699f3cce61460760db4dab7d2b69fc7426e9847
+  metadata.gz: 8aea75dac63b1dabf1775d84a99a7a7c80dde393436b72e9e76ae071889fc91f232d11cbcd272eac60c7ae734df2a6a805a3dc35ec976a58b191734b913c1a8e
+  data.tar.gz: f18071f7a38d32d9ca84ae82ae8e529c5c7e2237b4db87bae0f12eb591f30fbe97b5df599470c17a2dc59676335610cafe78f86ffc263d112a5bf38fd706459d

data/activerecord-libsql.gemspec

@@ -11,8 +11,9 @@ Gem::Specification.new do |spec|
   spec.summary = 'ActiveRecord adapter for Turso (libSQL) database'
   spec.description = <<~DESC
     An ActiveRecord adapter for Turso, the edge SQLite database powered by libSQL.
-    Uses a native Rust extension (via magnus) to connect directly to Turso via the
-    libSQL remote protocol, without requiring any external HTTP client.
+    Connects to Turso Cloud via the Hrana v2 HTTP protocol using Ruby's built-in
+    Net::HTTP, making it fork-safe and dependency-free. Supports Embedded Replica
+    mode via the sqlite3 gem for local read performance.
   DESC
   spec.homepage = 'https://github.com/aileron-inc/activerecord-libsql'
   spec.license = 'MIT'
@@ -23,17 +24,14 @@ Gem::Specification.new do |spec|
 
   spec.files = Dir[
     'lib/**/*.rb',
-    'ext/**/*.{rs,toml,rb}',
     '*.md',
-    '*.gemspec',
-    'Cargo.{toml,lock}'
+    '*.gemspec'
   ]
 
   spec.require_paths = ['lib']
-  spec.extensions = ['ext/turso_libsql/extconf.rb']
 
   spec.add_dependency 'activerecord', '>= 7.0'
-  spec.add_dependency 'rb_sys', '~> 0.9'
+  spec.add_dependency 'sqlite3', '>= 1.4'
 
   spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'rake-compiler', '~> 1.2'

data/lib/active_record/connection_adapters/libsql_adapter.rb

@@ -2,7 +2,7 @@
 
 require 'active_record'
 require 'active_record/connection_adapters/abstract_adapter'
-require 'turso_libsql/turso_libsql'
+require 'turso_libsql'
 
 # AR 7.2+ のアダプター登録 API
 ActiveSupport.on_load(:active_record) do
@@ -113,17 +113,40 @@ module ActiveRecord
         false
       end
 
-      def reconnect!
-        @raw_database, @raw_connection = build_libsql_connection
+      def disconnect!
+        @raw_connection = nil
+        @raw_database = nil
         super
       end
 
-      def disconnect!
+      # fork 後の子プロセスで呼ばれる。親プロセスの Rust オブジェクトを
+      # 子プロセスから触ると SEGV するため、参照を即座に破棄する。
+      # さらに tokio ランタイムも fork で壊れるため reinitialize_runtime! で作り直す。
+      # AR の ConnectionPool が fork 後に各コネクションに対して呼ぶ。
+      def discard!
         @raw_connection = nil
         @raw_database = nil
+        TursoLibsql.reinitialize_runtime!
         super
       end
 
+      private
+
+      # AR 8 の reconnect! が内部で呼ぶ private メソッド。
+      # 既存接続を破棄して新しい接続を確立する。
+      def reconnect
+        @raw_connection = nil
+        @raw_database = nil
+        @raw_database, @raw_connection = build_libsql_connection
+      end
+
+      # AR 8 の connect! が内部で呼ぶ private メソッド（一部のパスで使われる）。
+      def connect
+        @raw_database, @raw_connection = build_libsql_connection
+      end
+
+      public
+
       # Embedded Replica モードでリモートから最新フレームを手動同期する。
       # Remote モードでは何もしない（no-op）。
       def sync

data/lib/activerecord/libsql/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   module Libsql
-    VERSION = '0.1.2'
+    VERSION = '0.1.3'
   end
 end

data/lib/turso_libsql/connection.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module TursoLibsql
+  # Hrana v2 HTTP プロトコルを使ったリモート接続
+  # Net::HTTP を使用するため fork 後も安全
+  class Connection
+    def initialize(url, token)
+      @hrana_url = hrana_url(url)
+      @token = token
+      @baton = nil
+      @last_insert_rowid = 0
+      @last_affected_rows = 0
+    end
+
+    # SQL を実行し、影響を受けた行数を返す（INSERT/UPDATE/DELETE 用）
+    def execute(sql)
+      execute_sql(sql, [])
+    end
+
+    # SQL を実行し、結果を Array of Hash で返す（SELECT 用）
+    def query(sql)
+      query_sql(sql, [])
+    end
+
+    # プリペアドステートメントで SQL を実行（パラメータ付き）
+    def execute_with_params(sql, params)
+      json_params = params.map { |p| { 'type' => 'text', 'value' => p.to_s } }
+      execute_sql(sql, json_params)
+    end
+
+    # トランザクションを開始する
+    def begin_transaction
+      requests = [{ 'type' => 'execute', 'stmt' => { 'sql' => 'BEGIN' } }]
+      resp = hrana_pipeline(nil, requests)
+      @baton = resp['baton']
+      check_errors(resp)
+    end
+
+    # トランザクションをコミットする
+    def commit_transaction
+      requests = [
+        { 'type' => 'execute', 'stmt' => { 'sql' => 'COMMIT' } },
+        { 'type' => 'close' }
+      ]
+      resp = hrana_pipeline(@baton, requests)
+      @baton = nil
+      check_errors(resp)
+    end
+
+    # トランザクションをロールバックする
+    def rollback_transaction
+      requests = [
+        { 'type' => 'execute', 'stmt' => { 'sql' => 'ROLLBACK' } },
+        { 'type' => 'close' }
+      ]
+      # baton が無効になっている場合（サーバー側でエラー後に破棄された場合）は
+      # baton なしで ROLLBACK を試みる。失敗しても無視する（接続は既に破棄済み）
+      baton = @baton
+      @baton = nil
+      begin
+        resp = hrana_pipeline(baton, requests)
+        check_errors(resp)
+      rescue StandardError
+        # ROLLBACK 失敗は無視（接続が既に破棄されている場合）
+      end
+    end
+
+    # 最後に挿入した行の rowid を返す
+    attr_reader :last_insert_rowid
+
+    private
+
+    def execute_sql(sql, params)
+      stmt = build_stmt(sql, params)
+      requests = if @baton
+                   [stmt]
+                 else
+                   [stmt, { 'type' => 'close' }]
+                 end
+
+      resp = hrana_pipeline(@baton, requests)
+      check_errors(resp)
+
+      @baton = resp['baton'] if @baton
+      if (results = resp['results'])&.first
+        @last_affected_rows = results.first.dig('response', 'result', 'affected_row_count').to_i
+        rowid_str = results.first.dig('response', 'result', 'last_insert_rowid')
+        @last_insert_rowid = rowid_str.to_i
+      end
+
+      @last_affected_rows
+    end
+
+    def query_sql(sql, params)
+      stmt = build_stmt(sql, params)
+      requests = if @baton
+                   [stmt]
+                 else
+                   [stmt, { 'type' => 'close' }]
+                 end
+
+      resp = hrana_pipeline(@baton, requests)
+      check_errors(resp)
+
+      @baton = resp['baton'] if @baton
+
+      result = resp.dig('results', 0, 'response', 'result')
+      return [] unless result
+
+      cols = result['cols']&.map { |c| c['name'] } || []
+      rows = result['rows'] || []
+
+      rows.map do |row|
+        record = {}
+        cols.each_with_index do |col, i|
+          record[col] = hrana_value_to_ruby(row[i])
+        end
+        record
+      end
+    end
+
+    def build_stmt(sql, params)
+      stmt = { 'sql' => sql }
+      stmt['args'] = params if params.any?
+      { 'type' => 'execute', 'stmt' => stmt }
+    end
+
+    def hrana_pipeline(baton, requests)
+      body = { 'requests' => requests }
+      body['baton'] = baton if baton
+
+      uri = URI.parse(@hrana_url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == 'https')
+      http.open_timeout = 10
+      http.read_timeout = 30
+
+      request = Net::HTTP::Post.new(uri.path.empty? ? '/' : uri.path)
+      request['Authorization'] = "Bearer #{@token}"
+      request['Content-Type'] = 'application/json'
+      request.body = JSON.generate(body)
+
+      response = http.request(request)
+
+      raise "HTTP error #{response.code}: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+      JSON.parse(response.body)
+    rescue Net::OpenTimeout, Net::ReadTimeout, Errno::ECONNREFUSED,
+           SocketError, Socket::ResolutionError => e
+      raise "HTTP request failed: #{@hrana_url}: #{e.message}"
+    end
+
+    def check_errors(resp)
+      return unless (results = resp['results'])
+
+      results.each do |r|
+        next unless r['type'] == 'error'
+
+        msg = r.dig('error', 'message') || 'Unknown error'
+        raise msg
+      end
+    end
+
+    def hrana_value_to_ruby(cell)
+      return nil if cell.nil?
+
+      type = cell['type']
+      val  = cell['value']
+
+      case type
+      when 'null'    then nil
+      when 'integer' then val.to_i
+      when 'float'   then val.to_f
+      when 'text'    then val.to_s
+      when 'blob'    then val.to_s
+      end
+    end
+
+    def hrana_url(url)
+      # libsql:// → https:// に変換
+      if url.start_with?('libsql://')
+        "https://#{url.sub('libsql://', '')}/v2/pipeline"
+      else
+        "#{url.chomp('/')}/v2/pipeline"
+      end
+    end
+  end
+end

data/lib/turso_libsql/database.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative 'connection'
+
+module TursoLibsql
+  # Database ラッパー
+  # リモート接続と Embedded Replica の両方をサポート
+  class Database
+    # リモート接続用 Database を作成
+    def self.new_remote(url, token)
+      new(mode: :remote, url: url, token: token)
+    end
+
+    # Embedded Replica 用 Database を作成
+    def self.new_remote_replica(path, url, token, sync_interval_secs = 0)
+      new(mode: :replica, path: path, url: url, token: token, sync_interval: sync_interval_secs)
+    end
+
+    # Offline write 用 Database を作成
+    def self.new_synced(path, url, token, sync_interval_secs = 0)
+      new(mode: :offline, path: path, url: url, token: token, sync_interval: sync_interval_secs)
+    end
+
+    def initialize(mode:, url: nil, token: nil, path: nil, sync_interval: 0)
+      @mode = mode
+      @url = url
+      @token = token || ''
+      @path = path
+      @sync_interval = sync_interval
+    end
+
+    # この Database から Connection を取得して返す
+    def connect
+      case @mode
+      when :remote
+        Connection.new(@url, @token)
+      when :replica, :offline
+        # ローカルファイルを開く（なければ作成される）
+        LocalConnection.new(@path, @url, @token, @mode)
+      end
+    end
+
+    # リモートから最新フレームを手動で同期する
+    def sync
+      case @mode
+      when :remote
+        # remote モードでは no-op
+        nil
+      when :replica, :offline
+        replica_sync(@path, @url, @token, @mode == :offline)
+      end
+    end
+
+    private
+
+    def replica_sync(path, url, token, offline)
+      remote_conn = Connection.new(url, token)
+
+      # ローカル DB を開く
+      require 'sqlite3'
+      local = SQLite3::Database.new(path)
+      local.results_as_hash = true
+
+      # remote からテーブル一覧を取得
+      tables = remote_conn.query(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+      ).map { |r| r['name'] }
+
+      tables.each do |table|
+        # remote からスキーマを取得
+        schema_rows = remote_conn.query(
+          "SELECT sql FROM sqlite_master WHERE type='table' AND name='#{table.gsub("'", "''")}'"
+        )
+        next if schema_rows.empty?
+
+        schema = schema_rows.first['sql']
+        # CREATE TABLE "foo" (...) → CREATE TABLE IF NOT EXISTS "foo" (...)
+        create_sql = schema.sub(/\ACREATE TABLE\b/i, 'CREATE TABLE IF NOT EXISTS')
+        local.execute(create_sql)
+
+        # pull: remote → local（offline モードも pull してからローカル write を優先）
+        remote_rows = remote_conn.query("SELECT * FROM \"#{table.gsub('"', '""')}\"")
+        remote_rows.each do |row|
+          cols = row.keys.map { |c| "\"#{c.gsub('"', '""')}\"" }.join(', ')
+          vals = row.values.map { |v| v.nil? ? 'NULL' : "'#{v.to_s.gsub("'", "''")}'" }.join(', ')
+          local.execute("INSERT OR REPLACE INTO \"#{table.gsub('"', '""')}\" (#{cols}) VALUES (#{vals})")
+        end
+
+        next unless offline
+
+        # push: local → remote（offline モードのみ）
+        # results_as_hash = true なので Hash の配列が返る
+        local_rows = local.execute("SELECT * FROM \"#{table.gsub('"', '""')}\"")
+        next if local_rows.empty?
+
+        local_rows.each do |row|
+          cols = row.keys.map { |c| "\"#{c.gsub('"', '""')}\"" }.join(', ')
+          vals = row.values.map { |v| v.nil? ? 'NULL' : "'#{v.to_s.gsub("'", "''")}'" }.join(', ')
+          remote_conn.execute("INSERT OR REPLACE INTO \"#{table.gsub('"', '""')}\" (#{cols}) VALUES (#{vals})")
+        end
+      end
+
+      local.close
+    end
+  end
+
+  # ローカル SQLite 接続（Embedded Replica 用）
+  # sqlite3 gem を使用
+  class LocalConnection
+    def initialize(path, remote_url, token, mode)
+      require 'sqlite3'
+      @db = SQLite3::Database.new(path)
+      @db.results_as_hash = true
+      @remote_url = remote_url
+      @token = token
+      @mode = mode
+      @last_insert_rowid = 0
+      @last_affected_rows = 0
+    end
+
+    def execute(sql)
+      @db.execute(sql)
+      @last_affected_rows = @db.changes
+      @last_insert_rowid = @db.last_insert_row_id
+      @last_affected_rows
+    end
+
+    def query(sql)
+      @db.execute(sql)
+    end
+
+    def execute_with_params(sql, params)
+      @db.execute(sql, params)
+      @last_affected_rows = @db.changes
+      @last_insert_rowid = @db.last_insert_row_id
+      @last_affected_rows
+    end
+
+    def begin_transaction
+      @db.execute('BEGIN')
+    end
+
+    def commit_transaction
+      @db.execute('COMMIT')
+    end
+
+    def rollback_transaction
+      @db.execute('ROLLBACK')
+    end
+
+    attr_reader :last_insert_rowid
+  end
+end

data/lib/turso_libsql.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'turso_libsql/connection'
+require_relative 'turso_libsql/database'
+
+module TursoLibsql
+  # fork 後の子プロセスで呼ぶ（Ruby 実装では no-op）
+  # Net::HTTP は fork 後も安全なため何もしなくてよい
+  def self.reinitialize_runtime!
+    # no-op: Ruby の Net::HTTP は fork 後も安全
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-libsql
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - aileron
@@ -24,19 +24,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '7.0'
 - !ruby/object:Gem::Dependency
-  name: rb_sys
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '1.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -81,25 +81,23 @@ dependencies:
         version: '3.0'
 description: |
   An ActiveRecord adapter for Turso, the edge SQLite database powered by libSQL.
-  Uses a native Rust extension (via magnus) to connect directly to Turso via the
-  libSQL remote protocol, without requiring any external HTTP client.
+  Connects to Turso Cloud via the Hrana v2 HTTP protocol using Ruby's built-in
+  Net::HTTP, making it fork-safe and dependency-free. Supports Embedded Replica
+  mode via the sqlite3 gem for local read performance.
 email: []
 executables: []
-extensions:
-- ext/turso_libsql/extconf.rb
+extensions: []
 extra_rdoc_files: []
 files:
-- Cargo.lock
-- Cargo.toml
 - README.md
 - activerecord-libsql.gemspec
-- ext/turso_libsql/Cargo.toml
-- ext/turso_libsql/extconf.rb
-- ext/turso_libsql/src/lib.rs
 - lib/active_record/connection_adapters/libsql_adapter.rb
 - lib/activerecord-libsql.rb
 - lib/activerecord/libsql/railtie.rb
 - lib/activerecord/libsql/version.rb
+- lib/turso_libsql.rb
+- lib/turso_libsql/connection.rb
+- lib/turso_libsql/database.rb
 homepage: https://github.com/aileron-inc/activerecord-libsql
 licenses:
 - MIT