ActiveVersion

gem 'active_version'

# Generate translation support
rails g active_version:translations Post

# In your model
class Post < ApplicationRecord
  has_translations
end

# Usage
post = Post.create!(title: "Hello", body: "World")
post.translations.create!(locale: "fi", title: "Hei", body: "Maailma")

post.translate(:title, locale: "fi")  # => "Hei"
post.translation(locale: "fi")        # => PostTranslation instance

# Generate revision support
rails g active_version:revisions Post

# In your model
class Post < ApplicationRecord
  has_revisions
end

# Usage
post = Post.create!(title: "v1")
post.update!(title: "v2")  # Creates revision automatically

post.current_version        # => 1
post.revision(version: 1)   # => PostRevision instance
post.at_version(1)         # => Post instance at version 1
post.undo!                  # => Revert to previous version
post.diff_from(version: 1) # => { "changes" => { "title" => {...} } }

# Generate audit support
rails g active_version:audits Post --storage=json_column

# In your model
class Post < ApplicationRecord
  has_audits
end

# Usage
post = Post.create!(title: "Hello")
post.update!(title: "World")

post.audits.count                    # => 2
post.audits.last.audited_changes      # => {"title" => ["Hello", "World"]}
post.revision(version: 1)            # => Post instance at version 1

# Generate SQL for batch operations
sql = post.audit_sql
PostAudit.batch_insert_sql([post1, post2], force: true)
PostAudit.batch_insert_sql(force: true) { [post1, post2] }
PostRevision.batch_insert_sql(version: 1) do |batch|
  post1 = Post.create!(title: "A")
  post2 = Post.create!(title: "B")
  post3 = Post.create!(title: "C")
  post1.update!(title: "A1")
  post2.update!(title: "B1")
  post3.destroy!
end
PostAudit.batch_insert(force: true) do |batch|
  batch << post1
  batch << post2
end

# config/initializers/active_version.rb
ActiveVersion.configure do |config|
  config.auditing_enabled = true
  config.current_user_method = :current_user

  # Global fallback naming (prefer destination audit model config instead)
  config.translation_locale_column = :locale
  config.revision_version_column = :version
end

class PostAudit < ApplicationRecord
  include ActiveVersion::Audits::AuditRecord

  configure_audit do
    storage :json_column   # :json_column | :yaml_column | :mirror_columns
    action_column :action
    changes_column :audited_changes
    context_column :audited_context
    comment_column :comment
    version_column :version
    user_column :user_id
  end
end

class PostAudit < ApplicationRecord
  include ActiveVersion::Audits::AuditRecord

  register_storage_provider(:msgpack) do |_audit_class, _column_name|
    MyMsgpackCodec.new # must respond to #load and #dump
  end

  configure_audit do
    storage :msgpack
    action_column :action
    changes_column :audited_changes
    context_column :audited_context
  end
end

class PostRevision < ApplicationRecord
  include ActiveVersion::Revisions::RevisionRecord

  configure_revision(version_column: :version,
    foreign_key: :post_id
  )
end

class PostTranslation < ApplicationRecord
  include ActiveVersion::Translations::TranslationRecord

  configure_translation(locale_column: :locale,
    foreign_key: :post_id
  )
end

class Post < ApplicationRecord
  has_audits(
    table_name: "custom_post_audits",
    identity_resolver: :external_id, # optional: use custom identity value for auditable_id
    only: [:title, :body],        # Only track these fields
    except: [:internal_notes],    # Don't track these
    max_audits: 100,               # Limit storage
    associated_with: :company,     # Track associated model
    if: :should_audit?,            # Conditional auditing
    comment_required: true         # Require comments
  )
  
  has_revisions(
    # Revisions are always table-based
    table_name: "custom_post_revisions",
    foreign_key: :record_uuid,         # optional: custom FK column in revision table
    identity_resolver: :external_id    # optional: source value used for FK writes/queries
  )
  
  has_translations(
    # Translations are always table-based
    table_name: "custom_post_translations",
    foreign_key: :record_uuid          # optional: custom FK column in translation table
  )
end

# Keep infrastructure concerns in application code:
# - connection topology routing / connected_to blocks
# - partition management
# - replication / topology policy
#
# ActiveVersion intentionally does not route between connections/topologies.
# It follows your current ActiveRecord connection and declared model schema.

# Default runtime is ActiveRecord-backed.
ActiveVersion.runtime_adapter

# Advanced/non-AR integrations can provide their own adapter object:
# - base_connection
# - connection_for(model_class, version_type)
# Optional capability hooks:
# - supports_transactional_context?(connection)
# - supports_current_transaction_id?(connection)
#
# Example:
# ActiveVersion.runtime_adapter = MyCustomAdapter.new

# Optional boot-time contract check:
# ActiveVersion::Runtime.valid_adapter?(ActiveVersion.runtime_adapter) # => true/false

class MyCustomAdapter
  def base_connection
    # returns a connection-like object for global/runtime operations
  end

  def connection_for(model_class, version_type)
    # returns the connection-like object used for this source model/type
  end

  # Optional capability hooks. If omitted, ActiveVersion falls back to
  # adapter_name-based PostgreSQL detection.
  def supports_transactional_context?(connection)
    connection.adapter_name.to_s.casecmp("postgresql").zero?
  end

  def supports_current_transaction_id?(connection)
    connection.adapter_name.to_s.casecmp("postgresql").zero?
  end

  def supports_partition_catalog_checks?(connection)
    connection.adapter_name.to_s.casecmp("postgresql").zero?
  end
end

# Unified query interface
ActiveVersion::Query.audits(post, preload: :user, order_by: { desc: :created_at })
ActiveVersion::Query.translations(post, locale: "en")
ActiveVersion::Query.revisions(post, version: 2)

# Set global context
ActiveVersion.with_context(ip: request.ip, user_agent: request.user_agent) do
  post.update!(title: "New")
end

# Set per-model context
post.audit_context = { request_id: "123" }
post.save!

# Global
ActiveVersion.without_auditing do
  # ...
end

# Per-model
Post.without_auditing do
  # ...
end

# Per-instance
post.without_auditing do
  # ...
end

# 1. Generate audit tables
rails g active_version:audits Post --storage=json_column

# 2. Migrate data
ActiveVersion::Migrators::Audited.migrate(Post)

# 3. Update code
# Replace audited with has_audits

# 1. Generate revision tables
rails g active_version:revisions Post

# 2. Migrate data (manual or via migrator)
# 3. Update code