cloudflare-d1 0.1.0

data/lib/sequel/adapters/cloudflare_d1.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require "sequel"
+require "sequel/adapters/utils/unmodified_identifiers"
+require "cloudflare/d1/client"
+
+module Sequel
+  module CloudflareD1
+    class Database < Sequel::Database
+      include Sequel::UnmodifiedIdentifiers::DatabaseMethods
+
+      set_adapter_scheme :cloudflare_d1
+
+      def connect(server)
+        opts = server_opts(server)
+
+        @account_id = opts[:account_id] || ENV["CLOUDFLARE_ACCOUNT_ID"]
+        @api_token = opts[:api_token] || ENV["CLOUDFLARE_API_TOKEN"]
+        @database_id = opts[:database] || opts[:database_id]
+
+        raise Error, "account_id is required" unless @account_id
+        raise Error, "api_token is required" unless @api_token
+        raise Error, "database_id is required" unless @database_id
+
+        @client = ::Cloudflare::D1::Client.new(
+          account_id: @account_id,
+          api_token: @api_token
+        )
+      end
+
+      def disconnect_connection(conn)
+        # No persistent connection to close
+      end
+
+      def execute(sql, opts = OPTS)
+        synchronize(opts[:server]) do |conn|
+          result = @client.query(
+            database_id: @database_id,
+            sql: sql
+          )
+
+          result.dig("result", 0, "results")
+        end
+      end
+
+      def execute_dui(sql, opts = OPTS)
+        synchronize(opts[:server]) do |conn|
+          result = @client.query(
+            database_id: @database_id,
+            sql: sql
+          )
+
+          meta = result.dig("result", 0, "meta")
+          meta["changes"] || 0
+        end
+      end
+
+      def execute_insert(sql, opts = OPTS)
+        synchronize(opts[:server]) do |conn|
+          result = @client.query(
+            database_id: @database_id,
+            sql: sql
+          )
+
+          meta = result.dig("result", 0, "meta")
+          meta["last_row_id"]
+        end
+      end
+
+      def fetch_rows(sql)
+        rows = execute(sql)
+        rows.each { |row| yield row } if rows
+      end
+
+      def execute_ddl(sql, opts = OPTS)
+        execute(sql, opts)
+        nil
+      end
+
+      # Schema methods
+
+      def tables(opts = OPTS)
+        sql = <<-SQL
+          SELECT name FROM sqlite_master
+          WHERE type = 'table'
+          AND name NOT LIKE 'sqlite_%'
+          ORDER BY name
+        SQL
+
+        rows = execute(sql)
+        rows.map { |row| row["name"].to_sym }
+      end
+
+      def schema(table, opts = OPTS)
+        sql = "PRAGMA table_info(#{literal(table.to_s)})"
+        rows = execute(sql)
+
+        rows.map do |row|
+          column = row["name"].to_sym
+          info = {
+            type: type_literal_to_sequel_type(row["type"]),
+            allow_null: row["notnull"] == 0,
+            default: row["dflt_value"],
+            primary_key: row["pk"] == 1,
+            db_type: row["type"]
+          }
+          [column, info]
+        end
+      end
+
+      def indexes(table, opts = OPTS)
+        sql = "PRAGMA index_list(#{literal(table.to_s)})"
+        index_list = execute(sql)
+
+        index_list.map do |idx|
+          index_name = idx["name"]
+          unique = idx["unique"] == 1
+
+          columns_sql = "PRAGMA index_info(#{literal(index_name)})"
+          columns = execute(columns_sql)
+            .sort_by { |c| c["seqno"] }
+            .map { |c| c["name"].to_sym }
+
+          {
+            name: index_name.to_sym,
+            unique: unique,
+            columns: columns
+          }
+        end
+      end
+
+      def supports_create_table_if_not_exists?
+        true
+      end
+
+      def supports_drop_table_if_exists?
+        true
+      end
+
+      def supports_transaction_isolation_levels?
+        false
+      end
+
+      def supports_savepoints?
+        false
+      end
+
+      def supports_prepared_transactions?
+        false
+      end
+
+      def supports_deferrable_constraints?
+        true
+      end
+
+      def supports_transactional_ddl?
+        false
+      end
+
+      def transaction(opts = OPTS)
+        # D1 API doesn't support transactions across HTTP requests
+        # So we just yield without transaction support
+        yield
+      end
+
+      def database_type
+        :cloudflare_d1
+      end
+
+      def dataset_class_default
+        Dataset
+      end
+
+      private
+
+      def type_literal_to_sequel_type(type)
+        case type.to_s.upcase
+        when /INT/i
+          :integer
+        when /REAL|FLOAT|DOUBLE/i
+          :float
+        when /TEXT|CHAR|CLOB/i
+          :string
+        when /BLOB/i
+          :blob
+        when /NUMERIC|DECIMAL/i
+          :decimal
+        else
+          :string
+        end
+      end
+    end
+
+    class Dataset < Sequel::Dataset
+      include Sequel::UnmodifiedIdentifiers::DatasetMethods
+
+      def fetch_rows(sql)
+        rows = execute(sql)
+        if rows
+          rows.each do |row|
+            # Convert string keys to symbols
+            symbolized_row = row.transform_keys(&:to_sym)
+            yield symbolized_row
+          end
+        end
+      end
+
+      def insert_select(*values)
+        # D1 doesn't support RETURNING clause
+        execute_insert(insert_sql(*values))
+      end
+
+      def supports_insert_select?
+        false
+      end
+
+      def supports_returning?(type)
+        false
+      end
+
+      def supports_window_functions?
+        true
+      end
+
+      def supports_cte?
+        true
+      end
+
+      def supports_where_true?
+        true
+      end
+
+      def supports_derived_column_lists?
+        false
+      end
+
+      def complex_expression_sql_append(sql, op, args)
+        case op
+        when :'||'
+          # SQLite uses || for concatenation
+          super
+        else
+          super
+        end
+      end
+
+      def literal_false
+        "0"
+      end
+
+      def literal_true
+        "1"
+      end
+
+      def quote_identifiers?
+        true
+      end
+
+      def quoted_identifier_append(sql, name)
+        sql << '"' << name.to_s.gsub('"', '""') << '"'
+      end
+    end
+  end
+end
+

data/lib/tasks/database.rake

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "cloudflare/d1/client"
+
+namespace :db do
+  desc "Create the Cloudflare D1 database"
+  task create: :load_config do
+    config = ActiveRecord::Base.connection_config
+    client = Cloudflare::D1::Client.new(
+      account_id: config[:account_id] || ENV["CLOUDFLARE_ACCOUNT_ID"],
+      api_token: config[:api_token] || ENV["CLOUDFLARE_API_TOKEN"]
+    )
+
+    database_name = config[:database] || config[:database_id]
+
+    if database_name =~ /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+      puts "Database ID already exists: #{database_name}"
+      puts "Skipping creation."
+    else
+      begin
+        result = client.create_database(name: database_name)
+        puts "Created database: #{result['name']} (#{result['uuid']})"
+        puts ""
+        puts "Add this to your database.yml:"
+        puts "  database_id: #{result['uuid']}"
+      rescue Cloudflare::D1::Client::APIError => e
+        if e.message.include?("already exists")
+          puts "Database already exists: #{database_name}"
+        else
+          raise
+        end
+      end
+    end
+  end
+
+  desc "Drop the Cloudflare D1 database"
+  task drop: :load_config do
+    config = ActiveRecord::Base.connection_config
+    client = Cloudflare::D1::Client.new(
+      account_id: config[:account_id] || ENV["CLOUDFLARE_ACCOUNT_ID"],
+      api_token: config[:api_token] || ENV["CLOUDFLARE_API_TOKEN"]
+    )
+
+    database_id = config[:database_id] || config[:database]
+
+    unless database_id =~ /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+      abort "Error: database_id must be a UUID. Cannot drop database by name."
+    end
+
+    print "Are you sure you want to drop database #{database_id}? [y/N] "
+    confirmation = STDIN.gets.chomp
+
+    if confirmation.downcase == "y"
+      client.delete_database(database_id: database_id)
+      puts "Dropped database: #{database_id}"
+    else
+      puts "Cancelled."
+    end
+  end
+
+  desc "List all Cloudflare D1 databases"
+  task list: :load_config do
+    config = ActiveRecord::Base.connection_config
+    client = Cloudflare::D1::Client.new(
+      account_id: config[:account_id] || ENV["CLOUDFLARE_ACCOUNT_ID"],
+      api_token: config[:api_token] || ENV["CLOUDFLARE_API_TOKEN"]
+    )
+
+    databases = client.list_databases
+
+    if databases.empty?
+      puts "No databases found."
+    else
+      puts "Cloudflare D1 Databases:"
+      puts "-" * 80
+      databases.each do |db|
+        puts "Name: #{db['name']}"
+        puts "UUID: #{db['uuid']}"
+        puts "Created: #{db['created_at']}"
+        puts "Tables: #{db['num_tables']}"
+        puts "-" * 80
+      end
+    end
+  end
+
+  desc "Migrate the Cloudflare D1 database (run pending migrations)"
+  task migrate: :load_config do
+    ActiveRecord::Base.establish_connection
+    ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
+    ActiveRecord::MigrationContext.new(ActiveRecord::Migrator.migrations_paths).migrate
+  end
+
+  desc "Rollback the database one migration"
+  task rollback: :load_config do
+    step = ENV["STEP"] ? ENV["STEP"].to_i : 1
+    ActiveRecord::Base.establish_connection
+    ActiveRecord::MigrationContext.new(ActiveRecord::Migrator.migrations_paths).rollback(step)
+  end
+
+  desc "Display migration status"
+  task :migrate_status => :load_config do
+    ActiveRecord::Base.establish_connection
+
+    unless ActiveRecord::Base.connection.table_exists?("schema_migrations")
+      puts "Schema migrations table doesn't exist yet."
+      return
+    end
+
+    db_list = ActiveRecord::SchemaMigration.all_versions
+
+    puts "\nDatabase: #{ActiveRecord::Base.connection_config[:database_id]}\n\n"
+    puts "#{'Status'.center(10)}  #{'Migration ID'.ljust(14)}  Migration Name"
+    puts "-" * 80
+
+    ActiveRecord::MigrationContext.new(ActiveRecord::Migrator.migrations_paths).migrations.each do |migration|
+      status = db_list.include?(migration.version.to_s) ? "up" : "down"
+      puts "#{status.center(10)}  #{migration.version.to_s.ljust(14)}  #{migration.name}"
+    end
+
+    puts
+  end
+
+  desc "Reset the database (drop, create, migrate)"
+  task reset: [:drop, :create, :migrate]
+
+  desc "Setup the database (create and migrate)"
+  task setup: [:create, :migrate]
+
+  task :load_config do
+    require "active_record"
+    require "active_record/connection_adapters/cloudflare_d1_adapter"
+
+    # Load Rails database configuration if available
+    if defined?(Rails)
+      ActiveRecord::Base.configurations = Rails.application.config.database_configuration
+      ActiveRecord::Base.establish_connection(Rails.env.to_sym)
+    else
+      # Load from config/database.yml if it exists
+      db_config_path = File.expand_path("config/database.yml", Dir.pwd)
+      if File.exist?(db_config_path)
+        require "yaml"
+        require "erb"
+        configs = YAML.load(ERB.new(File.read(db_config_path)).result) || {}
+        env = ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+        config = configs[env]
+
+        if config
+          ActiveRecord::Base.configurations = { env => config }
+          ActiveRecord::Base.establish_connection(config)
+        else
+          abort "No database configuration found for environment: #{env}"
+        end
+      else
+        abort "No database configuration found. Create config/database.yml or set ENV variables."
+      end
+    end
+  end
+end

data/lib/tasks/sequel.rake

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require "sequel"
+require "cloudflare/d1/client"
+
+namespace :sequel do
+  namespace :db do
+    desc "Create the Cloudflare D1 database"
+    task :create do
+      require_sequel_connection_config
+
+      database_name = ENV["DATABASE_NAME"] || abort("DATABASE_NAME environment variable required")
+
+      if database_name =~ /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+        puts "Database ID already exists: #{database_name}"
+        puts "Skipping creation."
+      else
+        client = cloudflare_client
+        begin
+          result = client.create_database(name: database_name)
+          puts "Created database: #{result['name']} (#{result['uuid']})"
+          puts ""
+          puts "Set this environment variable:"
+          puts "  DATABASE_URL=cloudflare_d1://#{result['uuid']}"
+        rescue Cloudflare::D1::Client::APIError => e
+          if e.message.include?("already exists")
+            puts "Database already exists: #{database_name}"
+          else
+            raise
+          end
+        end
+      end
+    end
+
+    desc "Drop the Cloudflare D1 database"
+    task :drop do
+      require_sequel_connection_config
+
+      database_id = ENV["DATABASE_ID"] || abort("DATABASE_ID environment variable required")
+
+      unless database_id =~ /\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i
+        abort "Error: DATABASE_ID must be a UUID"
+      end
+
+      print "Are you sure you want to drop database #{database_id}? [y/N] "
+      confirmation = STDIN.gets.chomp
+
+      if confirmation.downcase == "y"
+        client = cloudflare_client
+        client.delete_database(database_id: database_id)
+        puts "Dropped database: #{database_id}"
+      else
+        puts "Cancelled."
+      end
+    end
+
+    desc "List all Cloudflare D1 databases"
+    task :list do
+      require_sequel_connection_config
+
+      client = cloudflare_client
+      databases = client.list_databases
+
+      if databases.empty?
+        puts "No databases found."
+      else
+        puts "Cloudflare D1 Databases:"
+        puts "-" * 80
+        databases.each do |db|
+          puts "Name: #{db['name']}"
+          puts "UUID: #{db['uuid']}"
+          puts "Created: #{db['created_at']}"
+          puts "Tables: #{db['num_tables']}"
+          puts "-" * 80
+        end
+      end
+    end
+
+    desc "Run migrations"
+    task :migrate, [:version] do |t, args|
+      require_sequel_connection_config
+      Sequel.extension :migration
+
+      db_url = ENV["DATABASE_URL"] || abort("DATABASE_URL environment variable required")
+      migrations_path = ENV["MIGRATIONS_PATH"] || "db/migrations"
+
+      Sequel.connect(db_url) do |db|
+        version = args[:version].to_i if args[:version]
+
+        if version
+          puts "Migrating to version #{version}"
+          Sequel::Migrator.run(db, migrations_path, target: version)
+        else
+          puts "Migrating to latest version"
+          Sequel::Migrator.run(db, migrations_path)
+        end
+
+        puts "Migration complete"
+      end
+    end
+
+    desc "Rollback the database one migration"
+    task :rollback, [:step] do |t, args|
+      require_sequel_connection_config
+      Sequel.extension :migration
+
+      db_url = ENV["DATABASE_URL"] || abort("DATABASE_URL environment variable required")
+      migrations_path = ENV["MIGRATIONS_PATH"] || "db/migrations"
+
+      Sequel.connect(db_url) do |db|
+        # Get current version
+        if db.table_exists?(:schema_info)
+          current_version = db[:schema_info].get(:version)
+
+          if current_version && current_version > 0
+            step = args[:step] ? args[:step].to_i : 1
+
+            # Get list of migrations
+            migrations = Dir[File.join(migrations_path, "*.rb")]
+              .map { |f| File.basename(f).split("_").first.to_i }
+              .sort
+
+            # Find target version
+            current_idx = migrations.index(current_version)
+            if current_idx && current_idx > 0
+              target_version = migrations[current_idx - step]
+
+              puts "Rolling back from version #{current_version} to #{target_version}"
+              Sequel::Migrator.run(db, migrations_path, target: target_version)
+              puts "Rollback complete"
+            else
+              puts "Already at first migration"
+            end
+          else
+            puts "No migrations to rollback"
+          end
+        else
+          puts "Schema info table doesn't exist yet"
+        end
+      end
+    end
+
+    desc "Display migration status"
+    task :status do
+      require_sequel_connection_config
+      Sequel.extension :migration
+
+      db_url = ENV["DATABASE_URL"] || abort("DATABASE_URL environment variable required")
+      migrations_path = ENV["MIGRATIONS_PATH"] || "db/migrations"
+
+      Sequel.connect(db_url) do |db|
+        unless db.table_exists?(:schema_info)
+          puts "Schema info table doesn't exist yet."
+          return
+        end
+
+        current_version = db[:schema_info].get(:version) || 0
+
+        puts "\nDatabase: #{ENV['DATABASE_ID'] || ENV['DATABASE_URL']}\n"
+        puts "Current version: #{current_version}\n\n"
+        puts "#{'Status'.center(10)}  #{'Version'.ljust(14)}  Migration File"
+        puts "-" * 80
+
+        migrations = Dir[File.join(migrations_path, "*.rb")].sort
+        migrations.each do |migration_file|
+          filename = File.basename(migration_file)
+          version = filename.split("_").first.to_i
+          name = filename.gsub(/^\d+_/, "").gsub(/\.rb$/, "")
+
+          status = version <= current_version ? "up" : "down"
+          puts "#{status.center(10)}  #{version.to_s.ljust(14)}  #{name}"
+        end
+
+        puts
+      end
+    end
+
+    desc "Reset the database (drop, create, migrate)"
+    task reset: [:drop, :create, :migrate]
+
+    desc "Setup the database (create and migrate)"
+    task setup: [:create, :migrate]
+  end
+
+  def require_sequel_connection_config
+    require "sequel"
+    require "sequel/adapters/cloudflare_d1"
+  end
+
+  def cloudflare_client
+    account_id = ENV["CLOUDFLARE_ACCOUNT_ID"] || abort("CLOUDFLARE_ACCOUNT_ID environment variable required")
+    api_token = ENV["CLOUDFLARE_API_TOKEN"] || abort("CLOUDFLARE_API_TOKEN environment variable required")
+
+    Cloudflare::D1::Client.new(
+      account_id: account_id,
+      api_token: api_token
+    )
+  end
+end

data/sig/cloudflare/d1.rbs

@@ -0,0 +1,6 @@
+module Cloudflare
+  module D1
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end