PgMultitenantSchemas

gem 'pg_multitenant_schemas'

PgMultitenantSchemas.configure do |config|
  config.connection_class = 'ApplicationRecord'  # or 'ActiveRecord::Base'
  config.tenant_model_class = 'Tenant'           # your tenant model
  config.default_schema = 'public'
  config.excluded_subdomains = ['www', 'api', 'admin']
  config.development_fallback = true            # for development
  config.auto_create_schemas = true             # automatically create missing schemas
end

# Use the Migrator directly in your code
PgMultitenantSchemas::Migrator.migrate_all
PgMultitenantSchemas::Migrator.setup_tenant('new_client')
PgMultitenantSchemas::Migrator.migration_status

# Extract tenant from subdomain
subdomain = PgMultitenantSchemas.extract_subdomain('acme.myapp.com')
# => 'acme'

# Find tenant by subdomain
tenant = PgMultitenantSchemas.find_tenant_by_subdomain('acme')

# Resolve tenant from Rails request
tenant = PgMultitenantSchemas.resolve_tenant_from_request(request)

# Switch to tenant context
PgMultitenantSchemas.switch_to_tenant(tenant)

# Use block-based context switching
PgMultitenantSchemas.with_tenant(tenant) do
  # All queries here use tenant's schema
  User.all  # Queries tenant_123.users
end

# Check current context
PgMultitenantSchemas.current_tenant
PgMultitenantSchemas.current_schema

class ApplicationController < ActionController::Base
  include PgMultitenantSchemas::Rails::ControllerConcern
  
  before_action :resolve_tenant
  
  private
  
  def resolve_tenant
    tenant = resolve_tenant_from_subdomain
    switch_to_tenant(tenant) if tenant
  end
end

class Tenant < ApplicationRecord
  include PgMultitenantSchemas::Rails::ModelConcern
  
  after_create :create_tenant_schema
  after_destroy :drop_tenant_schema
end

# ✅ GOOD: Isolated tenant operations
PgMultitenantSchemas.with_tenant(tenant) do
  # All operations are isolated to this tenant's schema
  User.create!(name: "John", email: "john@example.com")
  Order.where(status: "pending").update_all(status: "processed")
end

# ❌ BAD: Cross-tenant data sharing (security risk!)
# Never do: tenant_a.users.merge(tenant_b.users)

# Platform owner needs aggregate statistics across all tenants
def platform_analytics
  PgMultitenantSchemas::SchemaSwitcher.with_connection do |conn|
    conn.execute(<<~SQL)
      SELECT 
        schemaname as tenant,
        COUNT(*) as total_users,
        SUM(revenue) as total_revenue
      FROM (
        SELECT 'tenant_a' as schemaname, COUNT(*) as users, 
               (SELECT SUM(amount) FROM tenant_a.orders) as revenue
        UNION ALL
        SELECT 'tenant_b' as schemaname, COUNT(*) as users,
               (SELECT SUM(amount) FROM tenant_b.orders) as revenue
      ) stats
      GROUP BY schemaname;
    SQL
  end
end

# Moving data between environments or consolidating tenants
def migrate_tenant_data(from_tenant, to_tenant)
  PgMultitenantSchemas.with_tenant(from_tenant) do
    users = User.all.to_a
  end
  
  PgMultitenantSchemas.with_tenant(to_tenant) do
    users.each { |user| User.create!(user.attributes.except('id')) }
  end
end

# Shared lookup tables that all tenants can read (e.g., countries, currencies)
class Country < ApplicationRecord
  self.table_name = 'public.countries'  # Shared across all schemas
end

# In tenant context, can still access shared data
PgMultitenantSchemas.with_tenant(tenant) do
  user = User.create!(name: "John", country: Country.find_by(code: 'US'))
end

# ❌ NEVER: Direct tenant-to-tenant communication
def share_data_between_tenants(tenant_a, tenant_b)
  # This violates tenant isolation!
end

# ❌ NEVER: Cross-tenant user authentication
def authenticate_user_across_tenants(email)
  # Users should only exist in their tenant's schema
end

# ❌ NEVER: Cross-tenant business logic
def process_order_with_other_tenant_data(order_id, other_tenant)
  # Business logic should be isolated per tenant
end

# ✅ Proper multi-tenant architecture
class ApplicationController < ActionController::Base
  include PgMultitenantSchemas::Rails::ControllerConcern
  
  before_action :authenticate_user!
  before_action :resolve_tenant
  before_action :ensure_user_belongs_to_tenant
  
  private
  
  def resolve_tenant
    @tenant = resolve_tenant_from_subdomain
    switch_to_tenant(@tenant) if @tenant
  end
  
  def ensure_user_belongs_to_tenant
    # Ensure current user can only access their tenant's data
    redirect_to_login unless current_user.tenant == @tenant
  end
end