better_auth 0.7.0 → 0.10.0

data/lib/better_auth/schema/sql.rb

@@ -12,6 +12,31 @@ module BetterAuth
         statements.concat(tables.flat_map { |_logical_name, table| index_statements(table, dialect) })
       end
 
+      def pending_statements(plan)
+        statements = plan.to_create.map do |change|
+          create_table_statement(change.logical_name, change.table, plan.dialect, plan.tables)
+        end
+        statements.concat(plan.to_add.flat_map do |change|
+          change.fields.map do |logical_field, attributes|
+            if logical_field.to_s == "id" && plan.dialect == :postgres
+              add_postgres_id_column_statements(change.table_name)
+            else
+              add_column_statement(change.table_name, logical_field, attributes, plan.dialect)
+            end
+          end
+        end.flatten)
+        statements.concat(plan.to_index.map do |change|
+          index_statement(
+            change.table_name,
+            change.field_name,
+            change.name,
+            plan.dialect,
+            unique: change.unique,
+            where_not_null: filtered_unique_index?(change.field, plan.dialect)
+          )
+        end)
+      end
+
       def create_table_statement(logical_name, table, dialect, tables = nil)
         table_name = table.fetch(:model_name)
         columns = table.fetch(:fields).map do |logical_field, attributes|
@@ -28,7 +53,7 @@ module BetterAuth
         when :mysql
           %(CREATE TABLE IF NOT EXISTS #{quote(table_name, dialect)} (\n  #{body}\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;)
         when :mssql
-          %(IF OBJECT_ID(N'#{quote(table_name, dialect)}', N'U') IS NULL\nCREATE TABLE #{quote(table_name, dialect)} (\n  #{body}\n);)
+          %(#{mssql_required_set_options}\nIF OBJECT_ID(N'#{quote(table_name, dialect)}', N'U') IS NULL\nCREATE TABLE #{quote(table_name, dialect)} (\n  #{body}\n);)
         else
           raise ArgumentError, "Unsupported SQL dialect: #{dialect}"
         end
@@ -52,7 +77,7 @@ module BetterAuth
         constraints = []
         column = attributes[:field_name] || physical_name(logical_field)
 
-        if attributes[:unique] && logical_field != "id"
+        if attributes[:unique] && logical_field != "id" && !(dialect == :mssql && !attributes[:required])
           constraints << unique_constraint(table_name, column, dialect)
         end
 
@@ -67,21 +92,62 @@ module BetterAuth
       def index_statements(table, dialect)
         table_name = table.fetch(:model_name)
         table.fetch(:fields).filter_map do |logical_field, attributes|
-          next unless attributes[:index]
+          nullable_unique_mssql = dialect == :mssql && attributes[:unique] && logical_field != "id" && !attributes[:required]
+          next if attributes[:unique] && !nullable_unique_mssql
+          next unless attributes[:index] || nullable_unique_mssql
 
           column = attributes[:field_name] || Schema.physical_name(logical_field)
-          name = "index_#{table_name}_on_#{column}"
-          case dialect
-          when :postgres, :sqlite
-            %(CREATE INDEX IF NOT EXISTS #{quote(name, dialect)} ON #{quote(table_name, dialect)} (#{quote(column, dialect)});)
-          when :mysql
-            %(CREATE INDEX #{quote(name, dialect)} ON #{quote(table_name, dialect)} (#{quote(column, dialect)});)
-          when :mssql
-            %(IF NOT EXISTS (SELECT name FROM sys.indexes WHERE name = '#{name.gsub("'", "''")}' AND object_id = OBJECT_ID(N'#{quote(table_name, dialect)}')) CREATE INDEX #{quote(name, dialect)} ON #{quote(table_name, dialect)} (#{quote(column, dialect)});)
-          end
+          unique = attributes[:unique] && dialect == :mssql
+          name = unique ? "uniq_#{table_name}_#{column}" : "index_#{table_name}_on_#{column}"
+          index_statement(table_name, column, name, dialect, unique: unique, where_not_null: filtered_unique_index?(attributes, dialect))
+        end
+      end
+
+      def add_column_statement(table_name, logical_field, attributes, dialect)
+        keyword = (dialect == :mssql) ? "ADD" : "ADD COLUMN"
+        %(ALTER TABLE #{quote(table_name, dialect)} #{keyword} #{column_definition(table_name, logical_field, attributes, dialect)};)
+      end
+
+      def add_postgres_id_column_statements(table_name)
+        quoted_table = quote(table_name, :postgres)
+        quoted_id = quote("id", :postgres)
+        [
+          %(ALTER TABLE #{quoted_table} ADD COLUMN #{quoted_id} text;),
+          %(UPDATE #{quoted_table} SET #{quoted_id} = md5(random()::text || clock_timestamp()::text || ctid::text) WHERE #{quoted_id} IS NULL;),
+          %(ALTER TABLE #{quoted_table} ALTER COLUMN #{quoted_id} SET NOT NULL;),
+          %(ALTER TABLE #{quoted_table} ADD PRIMARY KEY (#{quoted_id});)
+        ]
+      end
+
+      def index_statement(table_name, column, name, dialect, unique: false, where_not_null: false)
+        unique_prefix = unique ? "UNIQUE " : ""
+        case dialect
+        when :postgres, :sqlite
+          %(CREATE #{unique_prefix}INDEX IF NOT EXISTS #{quote(name, dialect)} ON #{quote(table_name, dialect)} (#{quote(column, dialect)});)
+        when :mysql
+          %(CREATE #{unique_prefix}INDEX #{quote(name, dialect)} ON #{quote(table_name, dialect)} (#{quote(column, dialect)});)
+        when :mssql
+          filter = where_not_null ? " WHERE #{quote(column, dialect)} IS NOT NULL" : ""
+          %(#{mssql_required_set_options}\nIF NOT EXISTS (SELECT name FROM sys.indexes WHERE name = '#{name.gsub("'", "''")}' AND object_id = OBJECT_ID(N'#{quote(table_name, dialect)}')) CREATE #{unique_prefix}INDEX #{quote(name, dialect)} ON #{quote(table_name, dialect)} (#{quote(column, dialect)})#{filter};)
         end
       end
 
+      def filtered_unique_index?(attributes, dialect)
+        dialect == :mssql && attributes[:unique] && !attributes[:required]
+      end
+
+      def mssql_required_set_options
+        <<~SQL.strip
+          SET ANSI_NULLS ON;
+          SET QUOTED_IDENTIFIER ON;
+          SET ANSI_WARNINGS ON;
+          SET ANSI_PADDING ON;
+          SET CONCAT_NULL_YIELDS_NULL ON;
+          SET ARITHABORT ON;
+          SET NUMERIC_ROUNDABORT OFF;
+        SQL
+      end
+
       def sql_type(logical_field, attributes, dialect)
         case attributes[:type]
         when "boolean"
@@ -121,7 +187,7 @@ module BetterAuth
           end
         else
           if dialect == :mysql
-            indexed = logical_field == "id" || attributes[:unique] || attributes[:index] || attributes[:references]
+            indexed = logical_field == "id" || attributes[:unique] || attributes[:index] || attributes[:references] || attributes[:sortable] || attributes.key?(:default_value)
             indexed ? "varchar(191)" : "text"
           elsif dialect == :mssql
             indexed = logical_field == "id" || attributes[:unique] || attributes[:index] || attributes[:references] || attributes[:sortable]
@@ -164,8 +230,9 @@ module BetterAuth
       end
 
       def foreign_key_constraint(table_name, column, reference, dialect, tables = nil)
-        target_model = tables&.fetch(reference.fetch(:model).to_s, nil)&.fetch(:model_name) || reference.fetch(:model)
-        target_field = reference.fetch(:field)
+        target_table = foreign_key_target_table(reference, tables)
+        target_model = target_table&.fetch(:model_name) || reference.fetch(:model)
+        target_field = foreign_key_target_field(reference, target_table)
         on_delete = reference[:on_delete] ? " ON DELETE #{reference[:on_delete].to_s.upcase}" : ""
 
         case dialect
@@ -178,6 +245,28 @@ module BetterAuth
         end
       end
 
+      def foreign_key_target_table(reference, tables)
+        return unless tables
+
+        model = reference.fetch(:model).to_s
+        tables.fetch(model, nil) || tables.each_value.find { |table| table.fetch(:model_name).to_s == model }
+      end
+
+      def foreign_key_target_field(reference, target_table)
+        field = reference.fetch(:field).to_s
+        return field unless target_table
+
+        fields = target_table.fetch(:fields)
+        attributes = fields.fetch(field, nil)
+        return attributes[:field_name] || physical_name(field) if attributes
+
+        if fields.each_value.any? { |data| data[:field_name].to_s == field }
+          field
+        else
+          physical_name(field)
+        end
+      end
+
       def quote(identifier, dialect)
         case dialect
         when :postgres, :sqlite

data/lib/better_auth/schema.rb

@@ -18,6 +18,7 @@ module BetterAuth
       tables.delete("verification") if secondary_storage?(options) && !verification_option(options, :store_in_database)
       tables.merge!(plugin_schema)
       tables["rateLimit"] = rate_limit_table(options) if rate_limit_option(options, :storage) == "database"
+      ensure_id_fields!(tables)
       tables.sort_by { |_name, table| table[:order] || Float::INFINITY }.to_h
     end
 
@@ -121,6 +122,15 @@ module BetterAuth
       }
     end
 
+    private_class_method def self.ensure_id_fields!(tables)
+      tables.each_value do |table|
+        fields = table.fetch(:fields)
+        next if fields.key?("id")
+
+        table[:fields] = id_field.merge(fields)
+      end
+    end
+
     private_class_method def self.base_fields
       id_field.merge(timestamp_fields)
     end
@@ -162,14 +172,19 @@ module BetterAuth
         schema.each do |raw_key, raw_table|
           key = storage_key(raw_key)
           table_data = symbolize_hash(raw_table || {})
-          existing = tables[key] || {model_name: table_data[:model_name] || physical_name(key), fields: {}}
-          existing[:model_name] = table_data[:model_name] || existing[:model_name] || physical_name(key)
+          existing = tables[key] || {model_name: table_data[:model_name] || physical_table_name(key), fields: {}}
+          existing[:model_name] = table_data[:model_name] || existing[:model_name] || physical_table_name(key)
           existing[:fields] = existing[:fields].merge(normalize_fields(table_data[:fields] || {}))
+          existing[:fields] = id_field.merge(existing[:fields]) unless core_table?(key) || existing[:fields].key?("id")
           tables[key] = existing
         end
       end
     end
 
+    private_class_method def self.core_table?(key)
+      %w[user session account verification].include?(key.to_s)
+    end
+
     private_class_method def self.normalize_fields(fields)
       fields.each_with_object({}) do |(raw_key, raw_value), result|
         key = storage_key(raw_key)
@@ -270,6 +285,24 @@ module BetterAuth
       underscore(value.to_s)
     end
 
+    private_class_method def self.physical_table_name(value)
+      pluralize_table_name(physical_name(value))
+    end
+
+    private_class_method def self.pluralize_table_name(value)
+      special = {
+        "apikey" => "api_keys",
+        "api_key" => "api_keys",
+        "wallet_address" => "wallet_addresses"
+      }
+      return special.fetch(value) if special.key?(value)
+      return value if value.end_with?("s")
+      return "#{value[0...-1]}ies" if value.end_with?("y") && value.match?(/[^aeiou]y\z/)
+      return "#{value}es" if value.match?(/(s|x|z|ch|sh)\z/)
+
+      "#{value}s"
+    end
+
     private_class_method def self.camelize_lower(value)
       parts = underscore(value).split("_")
       ([parts.first] + parts.drop(1).map(&:capitalize)).join

data/lib/better_auth/session.rb

@@ -45,7 +45,8 @@ module BetterAuth
         strategy: config[:strategy] || "compact",
         version: config[:version],
         cookie_prefix: ctx.context.options.advanced[:cookie_prefix] || "better-auth",
-        is_secure: ctx.context.auth_cookies[:session_data].name.start_with?(Cookies::SECURE_COOKIE_PREFIX)
+        is_secure: ctx.context.auth_cookies[:session_data].name.start_with?(Cookies::SECURE_COOKIE_PREFIX),
+        cookie_full_name: ctx.context.auth_cookies[:session_data].name
       )
       return nil unless payload
       return nil if payload["session"]["token"] && payload["session"]["token"] != token

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