active_version 1.0.0

data/lib/generators/active_version/audits/audits_generator.rb

@@ -0,0 +1,65 @@
+require "rails/generators"
+require "rails/generators/active_record"
+
+module ActiveVersion
+  module Generators
+    class AuditsGenerator < Rails::Generators::NamedBase
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      class_option :storage,
+        type: :string,
+        default: "json_column",
+        desc: "Storage type: json_column, yaml_column, or mirror_columns"
+
+      def create_audit_model
+        template "audit_model.rb.erb",
+          File.join("app/models", class_path, "#{file_name}_audit.rb")
+      end
+
+      def generate_migration_file
+        if options[:storage] == "mirror_columns"
+          migration_template "migration_table.rb.erb",
+            File.join("db/migrate", "create_#{table_name}.rb"),
+            migration_version: migration_version
+        else
+          migration_template "migration_jsonb.rb.erb",
+            File.join("db/migrate", "create_#{table_name}.rb"),
+            migration_version: migration_version
+        end
+      end
+
+      def inject_has_audits
+        model_path = File.join("app/models", class_path, "#{file_name}.rb")
+        return unless File.exist?(model_path)
+
+        inject_into_class(model_path, class_name) do
+          "  has_audits\n"
+        end
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::Migration.current_version}]"
+      end
+
+      def table_name
+        "#{file_name}_audits"
+      end
+
+      def audit_class_name
+        "#{class_name}Audit"
+      end
+
+      def foreign_key
+        "#{file_name}_id"
+      end
+
+      def storage_type
+        options[:storage] || "json_column"
+      end
+    end
+  end
+end

data/lib/generators/active_version/audits/templates/audit_model.rb.erb

@@ -0,0 +1,16 @@
+
+class <%= audit_class_name %> < ApplicationRecord
+  include ActiveVersion::Audits::AuditRecord
+
+  self.table_name = "<%= table_name %>"
+
+  configure_audit do
+    storage :<%= storage_type %>
+    action_column :action
+    changes_column :audited_changes
+    context_column :audited_context
+    comment_column :comment
+    version_column :version
+    user_column :user_id
+  end
+end

data/lib/generators/active_version/audits/templates/migration_jsonb.rb.erb

@@ -0,0 +1,33 @@
+class Create<%= audit_class_name.pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :<%= table_name %> do |t|
+      t.references :auditable, polymorphic: true, null: false, index: false
+      t.string :action, null: false
+      t.public_send(payload_column_type, :audited_changes, null: false)
+      t.integer :version, null: false
+      t.references :user, polymorphic: true
+      t.references :associated, polymorphic: true
+      t.text :comment
+      t.public_send(payload_column_type, :audited_context)
+      t.string :remote_address
+      t.string :request_uuid
+
+      t.timestamps
+    end
+
+    add_index :<%= table_name %>, [:auditable_type, :auditable_id, :version], unique: true, name: "index_<%= table_name %>_on_auditable_and_version"
+  end
+
+  private
+
+  def postgresql?
+    connection.adapter_name.to_s.casecmp("postgresql").zero?
+  end
+
+  def payload_column_type
+    return :jsonb if postgresql?
+    return :json if connection.native_database_types.is_a?(Hash) && connection.native_database_types.key?(:json)
+
+    :text
+  end
+end

data/lib/generators/active_version/audits/templates/migration_table.rb.erb

@@ -0,0 +1,34 @@
+class Create<%= audit_class_name.pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :<%= table_name %> do |t|
+      t.references :auditable, polymorphic: true, null: false, index: false
+      t.string :action, null: false
+      t.integer :version, null: false
+      t.references :user, polymorphic: true
+      t.references :associated, polymorphic: true
+      t.text :comment
+      t.public_send(payload_column_type, :audited_context)
+      t.string :remote_address
+      t.string :request_uuid
+
+      # Store changes as structured columns
+      # Note: Add columns based on your model's attributes
+      # Example:
+      # t.string :title
+      # t.text :body
+
+      t.timestamps
+    end
+
+    add_index :<%= table_name %>, [:auditable_type, :auditable_id, :version], unique: true, name: "index_<%= table_name %>_on_auditable_and_version"
+  end
+
+  private
+
+  def payload_column_type
+    return :jsonb if connection.adapter_name.to_s.casecmp("postgresql").zero?
+    return :json if connection.native_database_types.is_a?(Hash) && connection.native_database_types.key?(:json)
+
+    :text
+  end
+end

data/lib/generators/active_version/install/install_generator.rb

@@ -0,0 +1,19 @@
+require "rails/generators"
+
+module ActiveVersion
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates ActiveVersion initializer and configuration file"
+
+      def create_initializer
+        template "initializer.rb.erb", "config/initializers/active_version.rb"
+      end
+
+      def show_readme
+        readme "README" if behavior == :invoke
+      end
+    end
+  end
+end

data/lib/generators/active_version/install/templates/initializer.rb.erb

@@ -0,0 +1,38 @@
+
+# ActiveVersion Configuration
+# See https://github.com/amkisko/active_version.rb for documentation
+
+ActiveVersion.configure do |config|
+  # Global auditing control
+  config.auditing_enabled = true
+
+  # Current user method (for audits)
+  config.current_user_method = :current_user
+
+  # Ignored attributes (won't be tracked in audits/revisions)
+  config.ignored_attributes = %w[lock_version created_at updated_at created_on updated_on]
+
+  # Translation defaults
+  config.translation_locale_column = :locale
+  config.translation_default_locale = :en
+
+  # Revision defaults
+  config.revision_version_column = :version
+
+  # Audit defaults
+  # Prefer explicit destination model config via:
+  #   configure_audit { storage :json_column; action_column :action; ... }
+  #   configure_revision(version_column:, foreign_key:, ...)
+  #   configure_translation(locale_column:, foreign_key:, ...)
+  # These global values are fallbacks for audit models that do not declare schema.
+  config.audit_storage = :json_column
+  config.audit_auditable_column = :auditable
+  config.audit_associated_column = :associated
+  config.audit_remote_address_column = :remote_address
+  config.audit_request_uuid_column = :request_uuid
+
+  # Infrastructure note:
+  # Connection routing / connection topology / partition lifecycle are application-owned.
+  # ActiveVersion reads/writes using the active ActiveRecord connection.
+
+end

data/lib/generators/active_version/revisions/revisions_generator.rb

@@ -0,0 +1,71 @@
+require "rails/generators"
+require "rails/generators/active_record"
+
+module ActiveVersion
+  module Generators
+    class RevisionsGenerator < Rails::Generators::NamedBase
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      class_option :backfill,
+        type: :boolean,
+        default: false,
+        desc: "Create initial snapshots for existing records"
+
+      def create_revision_model
+        template "revision_model.rb.erb",
+          File.join("app/models", class_path, "#{file_name}_revision.rb")
+      end
+
+      def generate_migration_file
+        migration_template "migration.rb.erb",
+          File.join("db/migrate", "create_#{table_name}.rb"),
+          migration_version: migration_version
+      end
+
+      def inject_has_revisions
+        model_path = File.join("app/models", class_path, "#{file_name}.rb")
+        return unless File.exist?(model_path)
+
+        inject_into_class(model_path, class_name) do
+          "  has_revisions\n"
+        end
+      end
+
+      def create_backfill_migration
+        return unless options[:backfill]
+
+        migration_template "backfill_migration.rb.erb",
+          File.join("db/migrate", "backfill_#{table_name}.rb"),
+          migration_version: migration_version
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::Migration.current_version}]"
+      end
+
+      def table_name
+        "#{file_name}_revisions"
+      end
+
+      def revision_class_name
+        "#{class_name}Revision"
+      end
+
+      def foreign_key
+        "#{file_name}_id"
+      end
+
+      def version_column
+        ActiveVersion.config.revision_version_column
+      end
+
+      def source_table_name
+        file_name.pluralize
+      end
+    end
+  end
+end

data/lib/generators/active_version/revisions/templates/backfill_migration.rb.erb

@@ -0,0 +1,19 @@
+class Backfill<%= revision_class_name.pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def up
+    # Create initial snapshots for existing records
+    # Note: Adjust column list based on your actual source table structure
+    execute <<-SQL
+      INSERT INTO <%= table_name %> (<%= foreign_key %>, <%= version_column %>, title, body, created_at, updated_at)
+      SELECT id, 1, title, body, created_at, updated_at
+      FROM <%= source_table_name %>
+      WHERE id NOT IN (SELECT DISTINCT <%= foreign_key %> FROM <%= table_name %>)
+    SQL
+  end
+
+  def down
+    # Remove initial snapshots
+    execute <<-SQL
+      DELETE FROM <%= table_name %> WHERE <%= version_column %> = 1
+    SQL
+  end
+end

data/lib/generators/active_version/revisions/templates/migration.rb.erb

@@ -0,0 +1,20 @@
+class Create<%= revision_class_name.pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :<%= table_name %> do |t|
+      t.references :<%= file_name %>, null: false, foreign_key: true, index: false
+      t.integer :<%= version_column %>, null: false
+
+      # Copy all columns from source table
+      # Note: This is a simplified version - in production, you'd want to
+      # inspect the actual source table columns dynamically
+      # For now, we'll add common columns that can be customized
+      t.text :title
+      t.text :body
+      # Add other columns as needed
+
+      t.timestamps
+    end
+
+    add_index :<%= table_name %>, [:<%= foreign_key %>, :<%= version_column %>], unique: true, name: "index_<%= table_name %>_on_<%= foreign_key %>_and_<%= version_column %>"
+  end
+end

data/lib/generators/active_version/revisions/templates/revision_model.rb.erb

@@ -0,0 +1,8 @@
+
+class <%= revision_class_name %> < ApplicationRecord
+  include ActiveVersion::Revisions::RevisionRecord
+
+  configure_revision(version_column: :<%= version_column %>,
+    foreign_key: :<%= foreign_key %>
+  )
+end

data/lib/generators/active_version/translations/templates/migration.rb.erb

@@ -0,0 +1,16 @@
+class Create<%= translation_class_name.pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :<%= table_name %> do |t|
+      t.references :<%= file_name %>, null: false, foreign_key: true, index: false
+      t.string :<%= locale_column %>, null: false
+
+<% migration_attributes.each do |attr| -%>
+      <%= attr %>
+<% end -%>
+
+      t.timestamps
+    end
+
+    add_index :<%= table_name %>, [:<%= foreign_key %>, :<%= locale_column %>], unique: true, name: "index_<%= table_name %>_on_<%= foreign_key %>_and_<%= locale_column %>"
+  end
+end

data/lib/generators/active_version/translations/templates/translation_model.rb.erb

@@ -0,0 +1,15 @@
+
+class <%= translation_class_name %> < ApplicationRecord
+  include ActiveVersion::Translations::TranslationRecord
+
+  configure_translation(locale_column: :<%= locale_column %>,
+    foreign_key: :<%= foreign_key %>
+  )
+
+<% if translated_attributes.any? -%>
+  # Translated attributes:
+<% translated_attributes.each do |attr| -%>
+  #   <%= attr.split(':').first %>
+<% end -%>
+<% end -%>
+end

data/lib/generators/active_version/translations/translations_generator.rb

@@ -0,0 +1,73 @@
+require "rails/generators"
+require "rails/generators/active_record"
+
+module ActiveVersion
+  module Generators
+    class TranslationsGenerator < Rails::Generators::NamedBase
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      argument :attributes, type: :array, default: [], banner: "field:type field:type"
+
+      class_option :translated_attributes,
+        type: :array,
+        default: [],
+        desc: "Attributes to translate (e.g., title:string body:text)"
+
+      def create_translation_model
+        template "translation_model.rb.erb",
+          File.join("app/models", class_path, "#{file_name}_translation.rb")
+      end
+
+      def generate_migration_file
+        migration_template "migration.rb.erb",
+          File.join("db/migrate", "create_#{table_name}.rb"),
+          migration_version: migration_version
+      end
+
+      def inject_has_translations
+        model_path = File.join("app/models", class_path, "#{file_name}.rb")
+        return unless File.exist?(model_path)
+
+        inject_into_class(model_path, class_name) do
+          "  has_translations\n"
+        end
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::Migration.current_version}]"
+      end
+
+      def table_name
+        "#{file_name}_translations"
+      end
+
+      def translation_class_name
+        "#{class_name}Translation"
+      end
+
+      def foreign_key
+        "#{file_name}_id"
+      end
+
+      def locale_column
+        ActiveVersion.config.translation_locale_column
+      end
+
+      def translated_attributes
+        options[:translated_attributes] || []
+      end
+
+      def migration_attributes
+        translated_attributes.map do |attr|
+          name, type = attr.split(":")
+          type ||= "string"
+          "t.#{type} :#{name}"
+        end
+      end
+    end
+  end
+end

data/lib/generators/active_version/triggers/templates/migration.rb.erb

@@ -0,0 +1,100 @@
+class Add<%= type.camelize %>TriggerTo<%= class_name.pluralize %> < ActiveRecord::Migration<%= migration_version %>
+  def up
+    <%- if type == "audit" -%>
+    # Create audit trigger function
+    execute <<-SQL
+<%= ActiveVersion::Database::Triggers::PostgreSQL.generate_audit_trigger_function(
+  table_name,
+  audit_table_name,
+  auditable_type: auditable_type,
+  version_column: ActiveVersion.config.audit_version_column,
+  changes_column: ActiveVersion.config.audit_changes_column,
+  context_column: ActiveVersion.config.audit_context_column,
+  action_column: ActiveVersion.config.audit_action_column
+).indent(4) %>
+    SQL
+
+    # Create audit trigger
+    execute <<-SQL
+<%= ActiveVersion::Database::Triggers::PostgreSQL.generate_audit_trigger(
+  table_name,
+  trigger_name: trigger_name,
+  events: events.map(&:to_sym)
+).indent(4) %>
+    SQL
+    <%- elsif type == "revision" -%>
+    # Create revision trigger function
+    execute <<-SQL
+<%= ActiveVersion::Database::Triggers::PostgreSQL.generate_revision_trigger_function(
+  table_name,
+  revision_table_name,
+  foreign_key: "#{file_name}_id",
+  version_column: ActiveVersion.config.revision_version_column,
+  columns: tracked_columns
+).indent(4) %>
+    SQL
+
+    # Create revision trigger
+    execute <<-SQL
+<%= ActiveVersion::Database::Triggers::PostgreSQL.generate_revision_trigger(
+  table_name,
+  trigger_name: trigger_name
+).indent(4) %>
+    SQL
+    <%- end -%>
+  end
+
+  def down
+    <%- if type == "audit" -%>
+    # Drop audit trigger
+    execute <<-SQL
+<%= ActiveVersion::Database::Triggers::PostgreSQL.drop_trigger(trigger_name, table_name).indent(4) %>
+    SQL
+
+    # Drop audit trigger function
+    execute <<-SQL
+<%= ActiveVersion::Database::Triggers::PostgreSQL.drop_trigger_function(trigger_function_name).indent(4) %>
+    SQL
+    <%- elsif type == "revision" -%>
+    # Drop revision trigger
+    execute <<-SQL
+<%= ActiveVersion::Database::Triggers::PostgreSQL.drop_trigger(trigger_name, table_name).indent(4) %>
+    SQL
+
+    # Drop revision trigger function
+    execute <<-SQL
+<%= ActiveVersion::Database::Triggers::PostgreSQL.drop_trigger_function(trigger_function_name).indent(4) %>
+    SQL
+    <%- end -%>
+  end
+
+  private
+
+  def table_name
+    "<%= table_name %>"
+  end
+
+  def audit_table_name
+    "<%= audit_table_name %>"
+  end
+
+  def revision_table_name
+    "<%= revision_table_name %>"
+  end
+
+  def auditable_type
+    "<%= auditable_type %>"
+  end
+
+  def trigger_name
+    "<%= trigger_name %>"
+  end
+
+  def trigger_function_name
+    "<%= trigger_function_name %>"
+  end
+
+  def tracked_columns
+    <%= tracked_columns.inspect %>
+  end
+end

data/lib/generators/active_version/triggers/triggers_generator.rb

@@ -0,0 +1,74 @@
+require "rails/generators"
+require "rails/generators/active_record"
+
+module ActiveVersion
+  module Generators
+    class TriggersGenerator < Rails::Generators::NamedBase
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      class_option :type,
+        type: :string,
+        default: "audit",
+        desc: "Trigger type: audit or revision"
+
+      class_option :events,
+        type: :array,
+        default: ["insert", "update", "delete"],
+        desc: "Events to trigger on (for audits)"
+
+      def generate_trigger_migration_file
+        migration_template "migration.rb.erb",
+          File.join("db/migrate", "add_#{type}_trigger_to_#{table_name}.rb"),
+          migration_version: migration_version
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::Migration.current_version}]"
+      end
+
+      def table_name
+        file_name.pluralize
+      end
+
+      def type
+        options[:type] || "audit"
+      end
+
+      def events
+        options[:events] || ["insert", "update", "delete"]
+      end
+
+      def trigger_function_name
+        "active_version_#{type}_#{table_name}"
+      end
+
+      def trigger_name
+        "active_version_#{type}_on_#{table_name}"
+      end
+
+      def audit_table_name
+        "#{table_name}_audits"
+      end
+
+      def revision_table_name
+        "#{table_name}_revisions"
+      end
+
+      def auditable_type
+        file_name.classify
+      end
+
+      def tracked_columns
+        return [] unless ActiveRecord::Base.connected?
+
+        ActiveRecord::Base.connection.columns(table_name).map(&:name)
+      rescue ActiveRecord::NoDatabaseError, ActiveRecord::ConnectionNotEstablished, StandardError
+        []
+      end
+    end
+  end
+end

data/sig/active_version/advanced.rbs

@@ -0,0 +1,51 @@
+module ActiveVersion
+  module SchemaGuards
+    def self.validate_partitioned_keys!: (Class record_class, Symbol version_type) -> nil
+    def self.expected_unique_columns: (Class record_class, Symbol version_type) -> Array[String]
+    def self.postgres?: (untyped connection) -> bool
+    def self.partitioned_table?: (untyped connection, String table_name) -> bool
+    def self.partition_key_columns: (untyped connection, String table_name) -> Array[String]
+    def self.partition_primary_key_columns: (untyped connection, String table_name) -> Array[String]
+  end
+
+  module Query
+    def self.audits: (untyped record, ?Hash[Symbol, untyped] opts) -> untyped
+    def self.translations: (untyped record, ?Hash[Symbol, untyped] opts) -> untyped
+    def self.revisions: (untyped record, ?Hash[Symbol, untyped] opts) -> untyped
+    def self.current_transaction: (?Hash[Symbol, untyped] opts) -> untyped
+  end
+
+  module Sharding
+    class ConnectionRouter
+      def self.connection_for: (Class model_class, Symbol version_type) -> Symbol | String | untyped
+      def self.adapter_for: (Class model_class, Symbol version_type) -> untyped
+      def self.with_connection: (Class model_class, Symbol version_type) { (untyped) -> untyped } -> untyped
+    end
+  end
+
+  module Database
+    module Triggers
+      module PostgreSQL
+        def self.generate_audit_trigger_function: (String table_name, String audit_table_name, ?Hash[Symbol, untyped] options) -> String
+        def self.generate_audit_trigger: (String table_name, ?Hash[Symbol, untyped] options) -> String
+        def self.generate_revision_trigger_function: (String table_name, String revision_table_name, ?Hash[Symbol, untyped] options) -> String
+        def self.generate_revision_trigger: (String table_name, ?Hash[Symbol, untyped] options) -> String
+        def self.drop_trigger_function: (String function_name) -> String
+        def self.drop_trigger: (String trigger_name, String table_name) -> String
+      end
+    end
+  end
+
+  module Migrators
+    class Base
+      def self.migrate: (Class model_class, ?Hash[Symbol, untyped] options) -> Integer
+      def self.create_audit_table: (String table_name, ?Hash[Symbol, untyped] options) -> untyped
+      def self.create_revision_table: (String table_name, ?Hash[Symbol, untyped] options) -> untyped
+      def self.create_translation_table: (String table_name, ?Hash[Symbol, untyped] options) -> untyped
+    end
+
+    class Audited < Base
+      def self.migrate: (Class model_class, ?Hash[Symbol, untyped] options) -> Integer
+    end
+  end
+end