cloudflare-d1 0.1.0

data/lib/active_record/connection_adapters/cloudflare_d1_adapter.rb

@@ -0,0 +1,447 @@
+# frozen_string_literal: true
+
+require "active_record/connection_adapters/abstract_adapter"
+require "active_record/connection_adapters/statement_pool"
+require "cloudflare/d1/client"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class CloudflareD1Adapter < AbstractAdapter
+      ADAPTER_NAME = "CloudflareD1"
+
+      NATIVE_DATABASE_TYPES = {
+        primary_key: "INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL",
+        string: { name: "TEXT" },
+        text: { name: "TEXT" },
+        integer: { name: "INTEGER" },
+        float: { name: "REAL" },
+        decimal: { name: "NUMERIC" },
+        datetime: { name: "TEXT" },
+        time: { name: "TEXT" },
+        date: { name: "TEXT" },
+        binary: { name: "BLOB" },
+        boolean: { name: "INTEGER" },
+        json: { name: "TEXT" }
+      }.freeze
+
+      class << self
+        def new_client(config)
+          config
+        end
+
+        def dbconsole(config, options = {})
+          puts "D1 database console not available via adapter"
+          puts "Use: wrangler d1 execute #{config[:database_id]} --command='<SQL>'"
+        end
+      end
+
+      def initialize(...)
+        super
+
+        @config = @config.symbolize_keys
+        @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]
+
+        raise ArgumentError, "account_id is required" unless @account_id
+        raise ArgumentError, "api_token is required" unless @api_token
+        raise ArgumentError, "database_id is required" unless @database_id
+
+        @client = Cloudflare::D1::Client.new(
+          account_id: @account_id,
+          api_token: @api_token
+        )
+
+        @connection_parameters = @config
+        @prepared_statements = false
+      end
+
+      # Connection management
+
+      def active?
+        return false unless @client
+
+        # Try a simple query to check if connection is active
+        result = @client.query(
+          database_id: @database_id,
+          sql: "SELECT 1"
+        )
+        result["success"] == true
+      rescue
+        false
+      end
+
+      def reconnect
+        @client = Cloudflare::D1::Client.new(
+          account_id: @account_id,
+          api_token: @api_token
+        )
+      end
+      alias reconnect! reconnect
+
+      def disconnect!
+        @client = nil
+      end
+
+      def discard!
+        @client = nil
+      end
+
+      def reset!
+        reconnect
+      end
+
+      # Adapter info
+
+      def adapter_name
+        ADAPTER_NAME
+      end
+
+      def supports_ddl_transactions?
+        false # D1 API doesn't support transactions across HTTP requests
+      end
+
+      def supports_savepoints?
+        false
+      end
+
+      def supports_transaction_isolation?
+        false
+      end
+
+      def supports_explain?
+        true
+      end
+
+      def supports_index_sort_order?
+        true
+      end
+
+      def supports_datetime_with_precision?
+        false
+      end
+
+      def supports_json?
+        true
+      end
+
+      def supports_common_table_expressions?
+        true
+      end
+
+      def supports_virtual_columns?
+        false
+      end
+
+      def supports_insert_returning?
+        false
+      end
+
+      def supports_insert_on_conflict?
+        true
+      end
+      alias supports_insert_on_duplicate_skip? supports_insert_on_conflict?
+      alias supports_insert_on_duplicate_update? supports_insert_on_conflict?
+
+      def supports_concurrent_connections?
+        true
+      end
+
+      # Query execution
+
+      def execute(sql, name = nil)
+        log(sql, name) do
+          result = @client.query(
+            database_id: @database_id,
+            sql: sql
+          )
+
+          result["result"]
+        end
+      end
+
+      def exec_query(sql, name = "SQL", binds = [], prepare: false)
+        log(sql, name, binds) do
+          result = @client.query(
+            database_id: @database_id,
+            sql: sql,
+            params: binds.map { |b| type_cast(b) }
+          )
+
+          rows = result.dig("result", 0, "results") || []
+          columns = rows.first&.keys || []
+
+          ActiveRecord::Result.new(columns, rows.map(&:values), result.dig("result", 0, "meta") || {})
+        end
+      end
+
+      def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
+        sql = to_sql(arel, binds)
+
+        log(sql, name, binds) do
+          result = @client.query(
+            database_id: @database_id,
+            sql: sql,
+            params: binds.map { |b| type_cast(b) }
+          )
+
+          # Return the last inserted ID wrapped in array for multi-insert support
+          last_id = result.dig("result", 0, "meta", "last_row_id") || id_value
+          [last_id]
+        end
+      end
+
+      def affected_rows(result)
+        meta = result.instance_variable_get(:@meta)
+        return 0 unless meta
+        meta["changes"] || 0
+      end
+
+      def select_all(arel, name = nil, binds = [], preparable: nil, async: false, allow_retry: false)
+        arel = arel_from_relation(arel)
+        sql = to_sql(arel, binds)
+
+        if preparable.nil?
+          preparable = prepared_statements
+        end
+
+        exec_query(sql, name, binds, prepare: preparable)
+      end
+
+      def views
+        []
+      end
+
+      def data_sources
+        tables
+      end
+
+      def write_query?(sql)
+        !sql.match?(/\A\s*(SELECT|PRAGMA|EXPLAIN)/i)
+      end
+
+      def internal_exec_query(sql, name = "SQL", binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true)
+        exec_query(sql, name, binds, prepare: prepare)
+      end
+
+      def perform_query(raw_connection, sql, binds, type_casted_binds, prepare:, notification_payload:, batch:)
+        result = @client.query(
+          database_id: @database_id,
+          sql: sql,
+          params: type_casted_binds
+        )
+
+        rows = result.dig("result", 0, "results") || []
+        columns = rows.first&.keys || []
+        meta = result.dig("result", 0, "meta") || {}
+
+        ar_result = ActiveRecord::Result.new(columns, rows.map(&:values), meta)
+
+        # Store meta for affected_rows to access
+        ar_result.instance_variable_set(:@meta, meta)
+
+        ar_result
+      end
+
+      # Schema introspection
+
+      def tables(name = nil)
+        sql = <<-SQL
+          SELECT name FROM sqlite_master
+          WHERE type = 'table'
+          AND name NOT LIKE 'sqlite_%'
+          AND name NOT IN ('ar_internal_metadata')
+          ORDER BY name
+        SQL
+
+        result = execute(sql, name)
+        return [] unless result && result[0] && result[0]["results"]
+
+        result[0]["results"].map { |row| row["name"] }
+      end
+
+      def table_exists?(table_name)
+        tables.include?(table_name.to_s)
+      end
+
+      def columns(table_name)
+        sql = "PRAGMA table_info(#{quote_table_name(table_name)})"
+        result = execute(sql)
+
+        return [] unless result && result[0] && result[0]["results"]
+
+        result[0]["results"].map do |column_data|
+          column_name = column_data["name"]
+          sql_type = column_data["type"]
+          nullable = column_data["notnull"] == 0
+          default = column_data["dflt_value"]
+          type_metadata = fetch_type_metadata(sql_type)
+          cast_type = lookup_cast_type(sql_type)
+
+          ActiveRecord::ConnectionAdapters::Column.new(
+            column_name,
+            cast_type,
+            default,
+            type_metadata,
+            nullable
+          )
+        end
+      end
+
+      def primary_key(table_name)
+        sql = "PRAGMA table_info(#{quote_table_name(table_name)})"
+        result = execute(sql)
+
+        return "id" unless result && result[0] && result[0]["results"]
+
+        pk_column = result[0]["results"].find { |col| col["pk"] == 1 }
+        pk_column&.fetch("name", "id")
+      end
+
+      def native_database_types
+        NATIVE_DATABASE_TYPES
+      end
+
+      def indexes(table_name)
+        sql = "PRAGMA index_list(#{quote_table_name(table_name)})"
+        result = execute(sql)
+
+        return [] unless result && result[0] && result[0]["results"]
+
+        result[0]["results"].map do |index_data|
+          index_name = index_data["name"]
+          unique = index_data["unique"] == 1
+
+          # Get index columns
+          columns_sql = "PRAGMA index_info(#{quote(index_name)})"
+          columns_result = execute(columns_sql)
+          columns = []
+
+          if columns_result && columns_result[0] && columns_result[0]["results"]
+            columns = columns_result[0]["results"]
+              .sort_by { |c| c["seqno"] }
+              .map { |c| c["name"] }
+          end
+
+          ActiveRecord::ConnectionAdapters::IndexDefinition.new(
+            table_name,
+            index_name,
+            unique,
+            columns
+          )
+        end
+      end
+
+      # Quoting
+
+      def quote_string(s)
+        s.gsub("'", "''")
+      end
+
+      def quote_table_name(name)
+        "\"#{name.to_s.gsub('"', '""')}\""
+      end
+
+      def quote_column_name(name)
+        "\"#{name.to_s.gsub('"', '""')}\""
+      end
+
+      def quoted_true
+        "1"
+      end
+
+      def quoted_false
+        "0"
+      end
+
+      def quoted_date(value)
+        value.utc.iso8601
+      end
+
+      # Type casting
+
+      def type_cast(value)
+        case value
+        when ActiveModel::Attribute
+          type_cast(value.value_for_database)
+        when TrueClass
+          1
+        when FalseClass
+          0
+        when Time, DateTime
+          value.utc.iso8601
+        when Date
+          value.iso8601
+        else
+          value
+        end
+      end
+
+      private
+
+      def lookup_cast_type(sql_type)
+        case sql_type.to_s.upcase
+        when /INT/i
+          Type::Integer.new
+        when /REAL|FLOAT|DOUBLE/i
+          Type::Float.new
+        when /TEXT|CHAR|CLOB/i
+          Type::String.new
+        when /BLOB/i
+          Type::Binary.new
+        when /NUMERIC|DECIMAL/i
+          Type::Decimal.new
+        when ""
+          Type::Value.new
+        else
+          Type::String.new
+        end
+      end
+
+      def fetch_type_metadata(sql_type)
+        cast_type = case sql_type.to_s.upcase
+        when /INT/i
+          Type::Integer.new
+        when /REAL|FLOAT|DOUBLE/i
+          Type::Float.new
+        when /TEXT|CHAR|CLOB/i
+          Type::String.new
+        when /BLOB/i
+          Type::Binary.new
+        when /NUMERIC|DECIMAL/i
+          Type::Decimal.new
+        when ""
+          Type::Value.new
+        else
+          Type::String.new
+        end
+
+        ActiveRecord::ConnectionAdapters::SqlTypeMetadata.new(
+          sql_type: sql_type.to_s,
+          type: cast_type.type,
+          limit: cast_type.limit
+        )
+      end
+
+      def arel_from_relation(relation)
+        case relation
+        when Arel::TreeManager
+          relation
+        when String
+          Arel.sql(relation)
+        else
+          relation.arel
+        end
+      end
+    end
+  end
+end
+
+# Register the adapter
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::ConnectionAdapters.register(
+    "cloudflare_d1",
+    "ActiveRecord::ConnectionAdapters::CloudflareD1Adapter",
+    "active_record/connection_adapters/cloudflare_d1_adapter"
+  )
+end

data/lib/cloudflare/d1/client.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module Cloudflare
+  module D1
+    class Client
+      class APIError < StandardError; end
+
+      BASE_URL = "https://api.cloudflare.com/client/v4"
+
+      attr_reader :account_id, :api_token
+
+      def initialize(account_id:, api_token:)
+        @account_id = account_id
+        @api_token = api_token
+      end
+
+      # Execute a query against a D1 database
+      # @param database_id [String] The UUID of the D1 database
+      # @param sql [String] SQL query to execute
+      # @param params [Array] Optional parameters for parameterized queries
+      # @return [Hash] Response with results, meta, and success fields
+      def query(database_id:, sql:, params: [])
+        uri = URI("#{BASE_URL}/accounts/#{account_id}/d1/database/#{database_id}/query")
+
+        request = Net::HTTP::Post.new(uri)
+        request["Authorization"] = "Bearer #{api_token}"
+        request["Content-Type"] = "application/json"
+        request.body = JSON.generate({ sql: sql, params: params })
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        parse_response(response)
+      end
+
+      # Execute a raw query (returns results as arrays instead of objects)
+      # @param database_id [String] The UUID of the D1 database
+      # @param sql [String] SQL query to execute
+      # @param params [Array] Optional parameters for parameterized queries
+      # @return [Hash] Response with results as arrays
+      def raw_query(database_id:, sql:, params: [])
+        uri = URI("#{BASE_URL}/accounts/#{account_id}/d1/database/#{database_id}/raw")
+
+        request = Net::HTTP::Post.new(uri)
+        request["Authorization"] = "Bearer #{api_token}"
+        request["Content-Type"] = "application/json"
+        request.body = JSON.generate({ sql: sql, params: params })
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        parse_response(response)
+      end
+
+      # List all databases in the account
+      # @return [Array<Hash>] Array of database objects
+      def list_databases
+        uri = URI("#{BASE_URL}/accounts/#{account_id}/d1/database")
+
+        request = Net::HTTP::Get.new(uri)
+        request["Authorization"] = "Bearer #{api_token}"
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        data = parse_response(response)
+        data["result"] || []
+      end
+
+      # Get database details
+      # @param database_id [String] The UUID of the D1 database
+      # @return [Hash] Database object
+      def get_database(database_id:)
+        uri = URI("#{BASE_URL}/accounts/#{account_id}/d1/database/#{database_id}")
+
+        request = Net::HTTP::Get.new(uri)
+        request["Authorization"] = "Bearer #{api_token}"
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        data = parse_response(response)
+        data["result"]
+      end
+
+      # Create a new database
+      # @param name [String] Name for the new database
+      # @return [Hash] Created database object
+      def create_database(name:)
+        uri = URI("#{BASE_URL}/accounts/#{account_id}/d1/database")
+
+        request = Net::HTTP::Post.new(uri)
+        request["Authorization"] = "Bearer #{api_token}"
+        request["Content-Type"] = "application/json"
+        request.body = JSON.generate({ name: name })
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        data = parse_response(response)
+        data["result"]
+      end
+
+      # Delete a database
+      # @param database_id [String] The UUID of the D1 database
+      # @return [Boolean] Success status
+      def delete_database(database_id:)
+        uri = URI("#{BASE_URL}/accounts/#{account_id}/d1/database/#{database_id}")
+
+        request = Net::HTTP::Delete.new(uri)
+        request["Authorization"] = "Bearer #{api_token}"
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          http.request(request)
+        end
+
+        data = parse_response(response)
+        data["success"]
+      end
+
+      private
+
+      def parse_response(response)
+        case response
+        when Net::HTTPSuccess
+          data = JSON.parse(response.body)
+
+          if data["success"] == false
+            errors = data["errors"]&.map { |e| e["message"] }&.join(", ")
+            raise APIError, "D1 API Error: #{errors || 'Unknown error'}"
+          end
+
+          data
+        else
+          raise APIError, "HTTP Error #{response.code}: #{response.message}"
+        end
+      end
+    end
+  end
+end

data/lib/cloudflare/d1/model.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module Cloudflare
+  module D1
+    # Base class for D1-backed ActiveRecord models
+    #
+    # Example usage:
+    #
+    #   class User < Cloudflare::D1::Model
+    #     # Automatically uses D1 database named "users" (inferred from table_name)
+    #   end
+    #
+    #   # Configure in database.yml:
+    #   # production:
+    #   #   adapter: cloudflare_d1
+    #   #   account_id: <%= ENV['CLOUDFLARE_ACCOUNT_ID'] %>
+    #   #   api_token: <%= ENV['CLOUDFLARE_API_TOKEN'] %>
+    #   #   database_id: users_db_uuid
+    #
+    class Model < ActiveRecord::Base
+      self.abstract_class = true
+
+      class << self
+        # Returns the D1 database name inferred from the table name
+        # @return [String] The database name
+        def d1_database_name
+          table_name
+        end
+
+        # Returns the D1 database ID from the connection configuration
+        # @return [String] The database UUID
+        def d1_database_id
+          connection_db_config.configuration_hash[:database_id]
+        end
+
+        # Returns the Cloudflare account ID from the connection configuration
+        # @return [String] The account ID
+        def cloudflare_account_id
+          connection_db_config.configuration_hash[:account_id]
+        end
+      end
+    end
+  end
+end

data/lib/cloudflare/d1/railtie.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module Cloudflare
+  module D1
+    class Railtie < Rails::Railtie
+      rake_tasks do
+        load File.expand_path("../../tasks/database.rake", __dir__)
+      end
+    end
+  end
+end

data/lib/cloudflare/d1/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Cloudflare
+  module D1
+    VERSION = "0.1.0"
+  end
+end

data/lib/cloudflare/d1.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "d1/version"
+require_relative "d1/client"
+require_relative "d1/model"
+
+module Cloudflare
+  module D1
+    class Error < StandardError; end
+
+    class << self
+      attr_accessor :account_id, :api_token
+
+      # Configure global D1 settings
+      #
+      # Example:
+      #   Cloudflare::D1.configure do |config|
+      #     config.account_id = ENV['CLOUDFLARE_ACCOUNT_ID']
+      #     config.api_token = ENV['CLOUDFLARE_API_TOKEN']
+      #   end
+      def configure
+        yield self
+      end
+    end
+  end
+end
+
+# Load ActiveRecord adapter if ActiveRecord is available
+begin
+  require "active_record"
+  require_relative "../active_record/connection_adapters/cloudflare_d1_adapter"
+
+  # Load Rails integration if Rails is available
+  if defined?(Rails)
+    require_relative "d1/railtie"
+  end
+rescue LoadError
+  # ActiveRecord not available, skip adapter loading
+end