better_auth 0.8.0 → 0.10.0

data/lib/better_auth/social_providers/base.rb

@@ -7,6 +7,7 @@ require "net/http"
 require "openssl"
 require "time"
 require "uri"
+require_relative "../http_client"
 
 module BetterAuth
   module SocialProviders
@@ -67,11 +68,7 @@ module BetterAuth
               client_secret: client_secret
             )
           end,
-          verify_id_token: opts[:verify_id_token] || lambda do |token, _nonce = nil|
-            return false if opts[:disable_id_token_sign_in]
-
-            !decode_jwt_payload(token).empty?
-          end,
+          verify_id_token: opts[:verify_id_token],
           get_user_info: lambda do |tokens|
             custom = opts[:get_user_info]
             profile = if custom
@@ -277,7 +274,7 @@ module BetterAuth
         return nil if max_age && payload["iat"] && payload["iat"].to_i < Time.now.to_i - max_age.to_i
 
         payload
-      rescue JWT::DecodeError, JSON::ParserError, ArgumentError, OpenSSL::PKey::PKeyError
+      rescue JWT::DecodeError, JSON::ParserError, ArgumentError, OpenSSL::PKey::PKeyError, Net::OpenTimeout, Net::ReadTimeout, SocketError, SystemCallError
         nil
       end
 
@@ -312,9 +309,7 @@ module BetterAuth
       end
 
       def request_json(uri, request)
-        Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https", open_timeout: 5, read_timeout: 5) do |http|
-          http.request(request)
-        end
+        HTTPClient.request(uri, request)
       end
 
       def padded_base64(value)

data/lib/better_auth/social_providers/facebook.rb

@@ -28,7 +28,7 @@ module BetterAuth
         },
         **options
       )
-      provider[:verify_id_token] = provider[:options][:verify_id_token] || ->(token, _nonce = nil) { provider[:options][:disable_id_token_sign_in] ? false : !token.to_s.empty? }
+      provider.delete(:verify_id_token) unless provider[:verify_id_token]
       provider
     end
   end

data/lib/better_auth/social_providers/github.rb

@@ -43,6 +43,8 @@ module BetterAuth
             "User-Agent" => "better-auth"
           }
           profile = Base.get_json(user_info_endpoint, headers)
+          next nil unless profile
+
           emails = Base.get_json(emails_endpoint, headers)
           primary = Array(emails).find { |email| email["email"] == profile["email"] } ||
             Array(emails).find { |email| email["primary"] } ||

data/lib/better_auth/social_providers/line.rb

@@ -26,7 +26,7 @@ module BetterAuth
         },
         **options
       )
-      provider[:verify_id_token] = provider[:options][:verify_id_token] || ->(token, _nonce = nil) { provider[:options][:disable_id_token_sign_in] ? false : !Base.decode_jwt_payload(token).empty? }
+      provider.delete(:verify_id_token) unless provider[:verify_id_token]
       provider
     end
   end

data/lib/better_auth/social_providers/paypal.rb

@@ -29,7 +29,7 @@ module BetterAuth
         },
         **options
       )
-      provider[:verify_id_token] = provider[:options][:verify_id_token] || ->(token, _nonce = nil) { provider[:options][:disable_id_token_sign_in] ? false : !!Base.decode_jwt_payload(token)["sub"] }
+      provider.delete(:verify_id_token) unless provider[:verify_id_token]
       provider
     end
   end

data/lib/better_auth/sql_migration.rb

@@ -0,0 +1,566 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "better_auth/migration_plan"
+
+module BetterAuth
+  module SQLMigration
+    DEFAULT_MIGRATIONS_PATH = "db/better_auth/migrate"
+    MISSING_MIGRATIONS_TABLE_MESSAGES = [
+      /no such table/i,
+      /relation .* does not exist/i,
+      /table .* doesn't exist/i,
+      /undefined table/i,
+      /invalid object name/i
+    ].freeze
+
+    class UnsupportedAdapterError < StandardError; end
+
+    module_function
+
+    def render(options, dialect:, generator:)
+      dialect = normalize_dialect(dialect)
+      config = configuration_for(options)
+      statements = BetterAuth::Schema::SQL.create_statements(config, dialect: dialect)
+      [
+        "-- Generated by #{generator}",
+        "-- Dialect: #{dialect}",
+        "",
+        statements.join("\n\n"),
+        ""
+      ].join("\n")
+    end
+
+    def plan(options, connection:, dialect:)
+      dialect = normalize_dialect(dialect)
+      plan_from_existing(options, existing: current_schema(connection, dialect), dialect: dialect)
+    end
+
+    def plan_from_existing(options, existing:, dialect:)
+      dialect = normalize_dialect(dialect)
+      config = configuration_for(options)
+      desired = BetterAuth::Schema.auth_tables(config)
+      to_create = []
+      to_add = []
+      to_index = []
+      warnings = []
+
+      desired.each do |logical_name, table|
+        table_name = table.fetch(:model_name)
+        existing_table = existing[table_name]
+
+        unless existing_table
+          to_create << BetterAuth::MigrationPlan::TableChange.new(
+            logical_name: logical_name,
+            table_name: table_name,
+            table: table,
+            order: table[:order] || Float::INFINITY
+          )
+          table.fetch(:fields).each do |field, attributes|
+            next unless indexable_field?(attributes, dialect)
+
+            column = attributes[:field_name] || physical_name(field)
+            to_index << index_change(table_name, column, attributes, dialect: dialect, unique: !!attributes[:unique])
+          end
+          next
+        end
+
+        missing_fields = {}
+        table.fetch(:fields).each do |field, attributes|
+          column = attributes[:field_name] || physical_name(field)
+          existing_type = existing_table.fetch(:columns)[column]
+          if existing_type.nil?
+            missing_fields[field] = attributes
+          elsif !matching_type?(existing_type, attributes[:type], dialect)
+            warnings << "Type mismatch for #{table_name}.#{column}: expected #{attributes[:type]} but found #{existing_type.to_s.downcase}"
+          end
+
+          next unless attributes[:index] || attributes[:unique]
+          next if index_present?(existing_table, column, unique: !!attributes[:unique])
+
+          to_index << index_change(table_name, column, attributes, dialect: dialect, unique: !!attributes[:unique])
+        end
+
+        next if missing_fields.empty?
+
+        to_add << BetterAuth::MigrationPlan::FieldChange.new(
+          logical_name: logical_name,
+          table_name: table_name,
+          fields: missing_fields,
+          table: table,
+          order: table[:order] || Float::INFINITY
+        )
+      end
+
+      BetterAuth::MigrationPlan::Plan.new(
+        to_create: to_create.sort_by(&:order),
+        to_add: to_add.sort_by(&:order),
+        to_index: to_index,
+        warnings: warnings,
+        dialect: dialect,
+        tables: desired
+      )
+    end
+
+    def render_pending(options, connection:, dialect:, generator:)
+      dialect = normalize_dialect(dialect)
+      migration_plan = plan(options, connection: connection, dialect: dialect)
+      statements = BetterAuth::Schema::SQL.pending_statements(migration_plan)
+      return "" if statements.empty?
+
+      [
+        "-- Generated by #{generator}",
+        "-- Dialect: #{dialect}",
+        "",
+        statements.join("\n\n"),
+        ""
+      ].join("\n")
+    end
+
+    def generate(options, dialect:, generator:, migrations_path: DEFAULT_MIGRATIONS_PATH, timestamp: Time.now.utc.strftime("%Y%m%d%H%M%S"), connection: nil)
+      dialect = normalize_dialect(dialect)
+      FileUtils.mkdir_p(migrations_path)
+      path = File.join(migrations_path, "#{timestamp}_create_better_auth_tables.sql")
+      return path if File.exist?(path)
+
+      sql = if connection
+        render_pending(options, connection: connection, dialect: dialect, generator: generator)
+      else
+        render(options, dialect: dialect, generator: generator)
+      end
+      return nil if sql.empty?
+
+      File.write(path, sql)
+      path
+    end
+
+    def migrate(auth_or_options, migrations_path: DEFAULT_MIGRATIONS_PATH)
+      auth = auth_for(auth_or_options)
+      adapter = auth.context.adapter
+      unless adapter.respond_to?(:dialect) && adapter.respond_to?(:connection)
+        raise UnsupportedAdapterError, "Better Auth SQL migrations require core SQL adapters with connection and dialect support"
+      end
+
+      connection = adapter.connection
+      dialect = normalize_dialect(adapter.dialect)
+      files = Dir[File.join(migrations_path, "*.sql")].sort
+      ensure_schema_migrations!(connection, dialect)
+      applied = applied_migrations(connection, dialect)
+
+      files.reject { |file| applied.include?(File.basename(file)) }.each do |file|
+        execute_sql(connection, File.read(file))
+        record_migration(connection, dialect, File.basename(file))
+      end
+    end
+
+    def migrate_pending(auth_or_options)
+      auth = auth_for(auth_or_options)
+      adapter = auth.context.adapter
+      unless adapter.respond_to?(:dialect) && adapter.respond_to?(:connection)
+        raise UnsupportedAdapterError, "Better Auth SQL migrations require core SQL adapters with connection and dialect support"
+      end
+
+      connection = adapter.connection
+      dialect = normalize_dialect(adapter.dialect)
+      sql = render_pending(auth.options, connection: connection, dialect: dialect, generator: "better_auth")
+      return false if sql.empty?
+
+      if adapter.respond_to?(:transaction)
+        adapter.transaction { execute_sql(connection, sql) }
+      else
+        execute_sql(connection, sql)
+      end
+      true
+    end
+
+    def configuration_for(options)
+      return options.options if options.is_a?(BetterAuth::Auth)
+      return options if options.is_a?(BetterAuth::Configuration)
+
+      BetterAuth::Configuration.new(options)
+    end
+
+    def auth_for(value)
+      return value if value.is_a?(BetterAuth::Auth)
+
+      BetterAuth.auth(value)
+    end
+
+    def ensure_schema_migrations!(connection, dialect)
+      sql = case dialect
+      when :postgres, :sqlite
+        %(CREATE TABLE IF NOT EXISTS #{quote("better_auth_schema_migrations", dialect)} (#{quote("version", dialect)} text PRIMARY KEY);)
+      when :mysql
+        %(CREATE TABLE IF NOT EXISTS #{quote("better_auth_schema_migrations", dialect)} (#{quote("version", dialect)} varchar(191) PRIMARY KEY) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;)
+      when :mssql
+        %(IF OBJECT_ID(N'#{quote("better_auth_schema_migrations", dialect)}', N'U') IS NULL CREATE TABLE #{quote("better_auth_schema_migrations", dialect)} (#{quote("version", dialect)} varchar(255) PRIMARY KEY);)
+      else
+        raise UnsupportedAdapterError, "Unsupported SQL dialect for Better Auth migrations: #{dialect}"
+      end
+      execute_sql(connection, sql)
+    end
+
+    def applied_migrations(connection, dialect)
+      rows = execute_sql(connection, "SELECT #{quote("version", dialect)} FROM #{quote("better_auth_schema_migrations", dialect)};")
+      Array(rows).map { |row| row["version"] || row[:version] }
+    rescue UnsupportedAdapterError
+      raise
+    rescue => error
+      raise error unless missing_schema_migrations_table?(error)
+
+      []
+    end
+
+    def record_migration(connection, dialect, version)
+      sql = "INSERT INTO #{quote("better_auth_schema_migrations", dialect)} (#{quote("version", dialect)}) VALUES (#{literal(version)});"
+      execute_sql(connection, sql)
+    end
+
+    def execute_sql(connection, sql)
+      statements(sql).each_with_object([]) do |statement, results|
+        result =
+          if connection.respond_to?(:exec)
+            connection.exec(statement)
+          elsif connection.respond_to?(:execute)
+            connection.execute(statement)
+          elsif connection.respond_to?(:query)
+            connection.query(statement)
+          else
+            raise UnsupportedAdapterError, "SQL connection does not support exec, execute, or query"
+          end
+        results.concat(result.to_a) if result.respond_to?(:to_a)
+      end
+    end
+
+    def statements(sql)
+      normalized = sql.to_s.gsub("\r\n", "\n").strip
+      return [] if normalized.empty?
+
+      split_sql_statements(normalized)
+    end
+
+    def split_sql_statements(sql)
+      output = []
+      buffer = +""
+      index = 0
+      quote = nil
+      line_comment = false
+      block_comment = false
+      dollar_tag = nil
+
+      while index < sql.length
+        state = {
+          quote: quote,
+          line_comment: line_comment,
+          block_comment: block_comment,
+          dollar_tag: dollar_tag
+        }
+        index, quote, line_comment, block_comment, dollar_tag = scan_sql_character(sql, buffer, index, state, output)
+      end
+
+      tail = buffer.strip
+      output << tail unless tail.empty?
+      output
+    end
+
+    def scan_sql_character(sql, buffer, index, state, output)
+      char = sql[index]
+      next_char = sql[index + 1]
+      quote = state[:quote]
+      line_comment = state[:line_comment]
+      block_comment = state[:block_comment]
+      dollar_tag = state[:dollar_tag]
+
+      return scan_line_comment(buffer, index, char) + [quote, false, block_comment, dollar_tag] if line_comment && char == "\n"
+      return scan_line_comment(buffer, index, char) + [quote, true, block_comment, dollar_tag] if line_comment
+      return scan_block_comment(buffer, index, char, next_char, quote, line_comment, dollar_tag) if block_comment
+      return scan_dollar_quote(sql, buffer, index, char, quote, line_comment, block_comment, dollar_tag) if dollar_tag
+      return scan_quoted_string(sql, buffer, index, char, quote, line_comment, block_comment, dollar_tag) if quote
+      return [index + 2, quote, true, block_comment, dollar_tag].tap { buffer << char << next_char } if char == "-" && next_char == "-"
+      return [index + 2, quote, line_comment, true, dollar_tag].tap { buffer << char << next_char } if char == "/" && next_char == "*"
+
+      tag = dollar_quote_tag_at(sql, index)
+      return [index + tag.length, quote, line_comment, block_comment, tag].tap { buffer << tag } if tag
+      return [index + 1, char, line_comment, block_comment, dollar_tag].tap { buffer << char } if char == "'" || char == "\""
+
+      if char == ";"
+        statement = buffer.strip
+        output << statement unless statement.empty?
+        buffer.clear
+        return [index + 1, quote, line_comment, block_comment, dollar_tag]
+      end
+
+      buffer << char
+      [index + 1, quote, line_comment, block_comment, dollar_tag]
+    end
+
+    def scan_line_comment(buffer, index, char)
+      buffer << char
+      [index + 1]
+    end
+
+    def scan_block_comment(buffer, index, char, next_char, quote, line_comment, dollar_tag)
+      buffer << char
+      if char == "*" && next_char == "/"
+        buffer << next_char
+        [index + 2, quote, line_comment, false, dollar_tag]
+      else
+        [index + 1, quote, line_comment, true, dollar_tag]
+      end
+    end
+
+    def scan_dollar_quote(sql, buffer, index, char, quote, line_comment, block_comment, dollar_tag)
+      if sql[index, dollar_tag.length] == dollar_tag
+        buffer << dollar_tag
+        [index + dollar_tag.length, quote, line_comment, block_comment, nil]
+      else
+        buffer << char
+        [index + 1, quote, line_comment, block_comment, dollar_tag]
+      end
+    end
+
+    def scan_quoted_string(sql, buffer, index, char, quote, line_comment, block_comment, dollar_tag)
+      buffer << char
+      if char == quote && sql[index + 1] == quote
+        buffer << sql[index + 1]
+        [index + 2, quote, line_comment, block_comment, dollar_tag]
+      elsif char == quote
+        [index + 1, nil, line_comment, block_comment, dollar_tag]
+      else
+        [index + 1, quote, line_comment, block_comment, dollar_tag]
+      end
+    end
+
+    def dollar_quote_tag_at(sql, index)
+      match = sql[index..]&.match(/\A\$[A-Za-z_][A-Za-z0-9_]*\$|\A\$\$/)
+      match&.[](0)
+    end
+
+    def missing_schema_migrations_table?(error)
+      message = error.message.to_s
+      MISSING_MIGRATIONS_TABLE_MESSAGES.any? { |pattern| message.match?(pattern) }
+    end
+
+    def quote(identifier, dialect)
+      BetterAuth::Schema::SQL.quote(identifier, dialect)
+    end
+
+    def literal(value)
+      "'#{value.to_s.gsub("'", "''")}'"
+    end
+
+    def normalize_dialect(value)
+      dialect = case value.to_s.downcase
+      when "postgresql"
+        :postgres
+      when "sqlite3"
+        :sqlite
+      else
+        value.to_sym
+      end
+      return dialect if [:postgres, :sqlite, :mysql, :mssql].include?(dialect)
+
+      raise UnsupportedAdapterError, "Unsupported SQL dialect for Better Auth migrations: #{dialect}"
+    end
+
+    def current_schema(connection, dialect)
+      case dialect
+      when :sqlite
+        sqlite_schema(connection)
+      when :postgres
+        information_schema(connection, dialect, postgres_columns_sql, postgres_indexes_sql)
+      when :mysql
+        information_schema(connection, dialect, mysql_columns_sql, mysql_indexes_sql)
+      when :mssql
+        information_schema(connection, dialect, mssql_columns_sql, mssql_indexes_sql)
+      else
+        raise UnsupportedAdapterError, "Unsupported SQL dialect for Better Auth migrations: #{dialect}"
+      end
+    end
+
+    def sqlite_schema(connection)
+      table_rows = execute_sql(connection, "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%';")
+      table_rows.each_with_object({}) do |row, schema|
+        table_name = row["name"] || row[:name]
+        columns = execute_sql(connection, "PRAGMA table_info(#{quote(table_name, :sqlite)});").each_with_object({}) do |column, result|
+          result[column["name"] || column[:name]] = column["type"] || column[:type]
+        end
+        indexes = empty_index_metadata
+        execute_sql(connection, "PRAGMA index_list(#{quote(table_name, :sqlite)});").each do |index|
+          index_name = index["name"] || index[:name]
+          unique = (index["unique"] || index[:unique]).to_i == 1
+          indexes[:names] << index_name
+          execute_sql(connection, "PRAGMA index_info(#{quote(index_name, :sqlite)});").each do |field|
+            column = field["name"] || field[:name]
+            indexes[:columns] << column
+            indexes[:unique_columns] << column if unique
+          end
+        end
+        schema[table_name] = {name: table_name, columns: columns, indexes: indexes}
+      end
+    end
+
+    def information_schema(connection, dialect, columns_sql, indexes_sql)
+      schema = {}
+      execute_sql(connection, columns_sql).each do |row|
+        table_name = row_value(row, "table_name")
+        column_name = row_value(row, "column_name")
+        data_type = row_value(row, "data_type")
+        schema[table_name] ||= {name: table_name, columns: {}, indexes: empty_index_metadata}
+        schema[table_name][:columns][column_name] = data_type
+      end
+      execute_sql(connection, indexes_sql).each do |row|
+        table_name = row_value(row, "table_name")
+        column_name = row_value(row, "column_name")
+        index_name = row_value(row, "index_name")
+        unique_value = row_value(row, "unique") || row_value(row, "is_unique")
+        non_unique_value = row_value(row, "non_unique")
+        unique = (!unique_value.nil?) ? truthy_database_value?(unique_value) : non_unique_value.to_i == 0
+        schema[table_name] ||= {name: table_name, columns: {}, indexes: empty_index_metadata}
+        schema[table_name][:indexes][:names] << index_name if index_name
+        schema[table_name][:indexes][:columns] << column_name if column_name
+        schema[table_name][:indexes][:unique_columns] << column_name if column_name && !!unique
+      end
+      schema
+    end
+
+    def row_value(row, key)
+      candidates = [
+        key,
+        key.to_sym,
+        key.upcase,
+        key.upcase.to_sym,
+        camelize_lower(key),
+        camelize_lower(key).to_sym
+      ]
+      candidates.each { |candidate| return row[candidate] if row.key?(candidate) }
+      nil
+    end
+
+    def truthy_database_value?(value)
+      return value if value == true || value == false
+
+      value.to_i != 0
+    end
+
+    def camelize_lower(value)
+      parts = value.to_s.split("_")
+      ([parts.first] + parts.drop(1).map(&:capitalize)).join
+    end
+
+    def empty_index_metadata
+      {names: Set.new, columns: Set.new, unique_columns: Set.new}
+    end
+
+    def index_change(table_name, column, attributes, dialect:, unique:)
+      BetterAuth::MigrationPlan::IndexChange.new(
+        table_name: table_name,
+        field_name: column,
+        name: index_name(table_name, column, attributes, dialect),
+        unique: unique,
+        field: attributes
+      )
+    end
+
+    def indexable_field?(attributes, dialect)
+      attributes[:index] || filtered_unique_index?(attributes, dialect)
+    end
+
+    def filtered_unique_index?(attributes, dialect)
+      dialect == :mssql && attributes[:unique] && !attributes[:required]
+    end
+
+    def index_name(table_name, column, attributes, dialect)
+      filtered_unique_index?(attributes, dialect) ? "uniq_#{table_name}_#{column}" : "index_#{table_name}_on_#{column}"
+    end
+
+    def index_present?(table, column, unique:)
+      indexes = table.fetch(:indexes)
+      if unique
+        indexes[:unique_columns].include?(column) || indexes[:names].include?("index_#{table.fetch(:name, "")}_on_#{column}")
+      else
+        indexes[:columns].include?(column)
+      end
+    end
+
+    def matching_type?(actual_type, expected_type, dialect)
+      normalized = actual_type.to_s.downcase.split("(").first.strip
+      type = expected_type.to_s
+      expected = case type
+      when "string"
+        %w[text varchar character varying char uuid nvarchar uniqueidentifier]
+      when "number"
+        %w[integer int int4 bigint smallint numeric real decimal float double]
+      when "boolean"
+        %w[bool boolean integer tinyint bit smallint]
+      when "date"
+        %w[timestamptz timestamp date datetime datetime2]
+      when "json", "string[]", "number[]"
+        (dialect == :postgres) ? %w[json jsonb text] : %w[json text varchar nvarchar]
+      else
+        [normalized]
+      end
+      expected.include?(normalized)
+    end
+
+    def postgres_columns_sql
+      <<~SQL
+        SELECT table_name, column_name, data_type
+        FROM information_schema.columns
+        WHERE table_schema = current_schema();
+      SQL
+    end
+
+    def postgres_indexes_sql
+      <<~SQL
+        SELECT t.relname AS table_name, a.attname AS column_name, i.relname AS index_name, ix.indisunique AS unique
+        FROM pg_class t
+        JOIN pg_index ix ON t.oid = ix.indrelid
+        JOIN pg_class i ON i.oid = ix.indexrelid
+        JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+        JOIN pg_namespace n ON n.oid = t.relnamespace
+        WHERE t.relkind = 'r' AND n.nspname = current_schema();
+      SQL
+    end
+
+    def mysql_columns_sql
+      <<~SQL
+        SELECT table_name, column_name, data_type
+        FROM information_schema.columns
+        WHERE table_schema = DATABASE();
+      SQL
+    end
+
+    def mysql_indexes_sql
+      <<~SQL
+        SELECT table_name, column_name, index_name, CASE WHEN non_unique = 0 THEN 1 ELSE 0 END AS is_unique
+        FROM information_schema.statistics
+        WHERE table_schema = DATABASE();
+      SQL
+    end
+
+    def mssql_columns_sql
+      <<~SQL
+        SELECT t.name AS table_name, c.name AS column_name, ty.name AS data_type
+        FROM sys.tables t
+        JOIN sys.columns c ON c.object_id = t.object_id
+        JOIN sys.types ty ON ty.user_type_id = c.user_type_id;
+      SQL
+    end
+
+    def mssql_indexes_sql
+      <<~SQL
+        SELECT t.name AS table_name, c.name AS column_name, i.name AS index_name, i.is_unique
+        FROM sys.tables t
+        JOIN sys.indexes i ON i.object_id = t.object_id
+        JOIN sys.index_columns ic ON ic.object_id = t.object_id AND ic.index_id = i.index_id
+        JOIN sys.columns c ON c.object_id = t.object_id AND c.column_id = ic.column_id
+        WHERE i.name IS NOT NULL;
+      SQL
+    end
+
+    def physical_name(value)
+      BetterAuth::Schema.send(:physical_name, value)
+    end
+  end
+end

data/lib/better_auth/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BetterAuth
-  VERSION = "0.8.0"
+  VERSION = "0.10.0"
 end

data/lib/better_auth.rb

@@ -15,12 +15,15 @@ require_relative "better_auth/async"
 require_relative "better_auth/deprecate"
 require_relative "better_auth/logger"
 require_relative "better_auth/instrumentation"
+require_relative "better_auth/http_client"
 require_relative "better_auth/oauth2"
 require_relative "better_auth/password"
 require_relative "better_auth/plugin"
 require_relative "better_auth/configuration"
 require_relative "better_auth/schema"
 require_relative "better_auth/schema/sql"
+require_relative "better_auth/migration_plan"
+require_relative "better_auth/doctor"
 require_relative "better_auth/adapters/base"
 require_relative "better_auth/adapters/join_support"
 require_relative "better_auth/adapters/memory"