RailsSimpleAuth

gem "rails_simple_auth"

class User < ApplicationRecord
  authenticates_with :confirmable, :magic_linkable, :oauth, :temporary

  # Your custom fields and validations
  validates :company_name, presence: true
end

class User < ApplicationRecord
  authenticates_with
end

class ApplicationController < ActionController::Base
  before_action :require_authentication
end

# db/migrate/xxx_create_users.rb
class CreateUsers < ActiveRecord::Migration[8.0]
  def change
    create_table :users do |t|
      # Required by gem
      t.string :email, null: false
      t.string :password_digest, null: false
      t.datetime :confirmed_at  # if using Confirmable

      # Your custom fields
      t.string :name
      t.string :company_name
      t.boolean :admin, default: false
      t.string :oauth_provider
      t.string :oauth_uid

      t.timestamps
    end

    add_index :users, :email, unique: true
  end
end

# config/initializers/rails_simple_auth.rb
RailsSimpleAuth.configure do |config|
  # Features
  config.magic_link_enabled = true
  config.email_confirmation_enabled = true
  config.enable_oauth(:google, :github)

  # Token expiration
  config.magic_link_expiry = 15.minutes
  config.password_reset_expiry = 15.minutes
  config.confirmation_expiry = 24.hours

  # Paths (symbol, string, or proc)
  config.after_sign_in_path = :dashboard_path
  config.after_sign_out_path = -> { new_session_path }

  # Layout
  config.layout = "auth"  # Use a custom layout

  # Mailer
  config.mailer_sender = "auth@myapp.com"
  # config.mailer_class = "UserMailer"  # Use custom mailer (optional)

  # Password requirements
  config.password_minimum_length = 12

  # Callbacks
  config.after_sign_in_callback = ->(user, controller) {
    Analytics.track("sign_in", user_id: user.id)
  }
end

RailsSimpleAuth.configure do |config|
  config.enable_oauth(:google, :github)
end

# config/initializers/omniauth.rb
Rails.application.config.middleware.use OmniAuth::Builder do
  provider :google_oauth2, ENV["GOOGLE_CLIENT_ID"], ENV["GOOGLE_CLIENT_SECRET"]
  provider :github, ENV["GITHUB_CLIENT_ID"], ENV["GITHUB_CLIENT_SECRET"]
end

class User < ApplicationRecord
  authenticates_with :oauth

  def assign_oauth_attributes(auth_hash)
    self.name = auth_hash.dig("info", "name")
    self.avatar_url = auth_hash.dig("info", "image")
    self.oauth_provider = auth_hash["provider"]
    self.oauth_uid = auth_hash["uid"]
  end
end

class User < ApplicationRecord
  authenticates_with :confirmable, :temporary
end

RailsSimpleAuth.configure do |config|
  config.temporary_users_enabled = true
  config.temporary_user_cleanup_days = 7  # Auto-cleanup after 7 days
end

# In your controller
def try_without_account
  user = User.create!(
    email: "temp_#{SecureRandom.hex(8)}@temporary.local",
    password: SecureRandom.hex(32),
    temporary: true
  )

  # Sign them in
  create_session_for(user)
  redirect_to dashboard_path
end

def accept_invite
  # Create temporary user to access shared content
  user = User.create!(temporary: true, ...)
  create_session_for(user)
  redirect_to shared_workspace_path(params[:workspace_id])
end

# In your controller
def convert_account
  if current_user.convert_to_permanent!(
    email: params[:email],
    password: params[:password]
  )
    redirect_to dashboard_path, notice: "Account created! Please check your email to confirm."
  else
    # Validation failed (email taken, password blank, etc.)
    render :convert_form, status: :unprocessable_entity
  end
end

User.temporary           # All temporary users
User.permanent           # All permanent users
User.temporary_expired   # Temporary users older than cleanup_days

current_user.temporary?  # Is this a guest?
current_user.permanent?  # Is this a real account?

# In a rake task or background job
User.cleanup_expired_temporary!

# With custom retention period
User.cleanup_expired_temporary!(days: 14)

class CleanupTemporaryUsersJob < ApplicationJob
  def perform
    count = User.cleanup_expired_temporary!
    Rails.logger.info "Cleaned up #{count} expired temporary users"
  end
end

# app/controllers/sessions_controller.rb
class SessionsController < RailsSimpleAuth::SessionsController
  def after_sign_in(user)
    track_login(user)
    super
  end
end

rails_simple_auth_routes(sessions_controller: "sessions")

RailsSimpleAuth.configure do |config|
  # Sender address for all auth emails (required)
  config.mailer_sender = "auth@myapp.com"
  # Or use environment variable
  config.mailer_sender = ENV.fetch("MAILER_FROM", "noreply@example.com")
end

# config/initializers/rails_simple_auth.rb
RailsSimpleAuth.configure do |config|
  config.mailer_class = "UserMailer"
  config.mailer_sender = "hello@myapp.com"
end

# app/mailers/user_mailer.rb
class UserMailer < ApplicationMailer
  def confirmation(user, token)
    @user = user
    @confirmation_url = edit_confirmation_url(token: token)
    mail(to: user.email, subject: "Confirm your email")
  end

  def magic_link(user, token)
    @user = user
    @magic_link_url = magic_link_login_url(token: token)
    mail(to: user.email, subject: "Your sign-in link")
  end

  def password_reset(user, token)
    @user = user
    @reset_url = edit_password_url(token: token)
    mail(to: user.email, subject: "Reset your password")
  end
end

current_user          # The signed-in user (or nil)
user_signed_in?       # Boolean
require_authentication # Redirects if not signed in

RailsSimpleAuth::Current.user

RailsSimpleAuth.configure do |config|
  config.rate_limits = {
    sign_in: { limit: 10, period: 30.minutes },
    sign_up: { limit: 3, period: 1.hour },
    magic_link: { limit: 5, period: 15.minutes },
    password_reset: { limit: 5, period: 1.hour },
    confirmation: { limit: 5, period: 1.hour }
  }
end

config.rate_limits = {
  sign_in: nil,  # No rate limiting on sign in
  sign_up: { limit: 5, period: 1.hour }
}

RailsSimpleAuth.configure do |config|
  config.session_expiry = 30.days  # Default
  # config.session_expiry = 7.days  # Shorter sessions
end

# All sessions for a user
current_user.sessions

# Recent sessions first
current_user.sessions.recent

# Active sessions (not expired)
current_user.sessions.active

# Expired sessions
current_user.sessions.expired

# Clean up all expired sessions
RailsSimpleAuth::Session.cleanup_expired!

class CleanupExpiredSessionsJob < ApplicationJob
  def perform
    count = RailsSimpleAuth::Session.cleanup_expired!
    Rails.logger.info "Cleaned up #{count} expired sessions"
  end
end

# Migration
add_column :users, :admin, :boolean, default: false

class User < ApplicationRecord
  authenticates_with :confirmable

  def admin?
    admin == true
  end
end

class AdminController < ApplicationController
  before_action :require_admin

  private

  def require_admin
    redirect_to root_path, alert: "Not authorized" unless current_user&.admin?
  end
end

# Or as a concern
module AdminAuthentication
  extend ActiveSupport::Concern

  included do
    before_action :require_admin
  end

  private

  def require_admin
    redirect_to root_path, alert: "Not authorized" unless current_user&.admin?
  end
end

# Console
User.find_by(email: "admin@example.com").update!(admin: true)

# Seeds
User.create!(email: "admin@example.com", password: "secure123", admin: true)