active_version 1.0.0

data/lib/active_version/database/triggers/postgresql.rb

@@ -0,0 +1,243 @@
+module ActiveVersion
+  module Database
+    module Triggers
+      # PostgreSQL trigger support for ActiveVersion
+      module PostgreSQL
+        class << self
+          # Generate trigger function for audits
+          # @param table_name [String] Name of the table to create trigger for
+          # @param audit_table_name [String] Name of the audit table
+          # @param options [Hash] Trigger options
+          # @return [String] SQL for trigger function
+          def generate_audit_trigger_function(table_name, audit_table_name, options = {})
+            function_name = "active_version_audit_#{table_name}"
+            auditable_type = options[:auditable_type] || table_name.classify
+            version_column = options[:version_column] || "version"
+            changes_column = options[:changes_column] || "audited_changes"
+            context_column = options[:context_column] || "audited_context"
+            action_column = options[:action_column] || "action"
+
+            <<~SQL
+              CREATE OR REPLACE FUNCTION #{function_name}()
+              RETURNS TRIGGER AS $$
+              DECLARE
+                new_version INTEGER;
+                changes JSONB;
+                context_data JSONB;
+                action_type TEXT;
+              BEGIN
+                -- Determine action
+                IF TG_OP = 'INSERT' THEN
+                  action_type := 'create';
+                  changes := to_jsonb(NEW.*);
+                ELSIF TG_OP = 'UPDATE' THEN
+                  action_type := 'update';
+                  changes := jsonb_build_object(
+                    'old', to_jsonb(OLD.*),
+                    'new', to_jsonb(NEW.*)
+                  );
+                ELSIF TG_OP = 'DELETE' THEN
+                  action_type := 'destroy';
+                  changes := to_jsonb(OLD.*);
+                END IF;
+
+                -- Get version number
+                IF action_type = 'create' THEN
+                  new_version := 1;
+                ELSE
+                  SELECT COALESCE(MAX(#{version_column}), 0) + 1
+                  INTO new_version
+                  FROM #{audit_table_name}
+                  WHERE #{audit_table_name}.auditable_id = COALESCE(NEW.id, OLD.id)
+                    AND #{audit_table_name}.auditable_type = '#{auditable_type}';
+                END IF;
+
+                -- Get context from session variables (if set)
+                context_data := COALESCE(
+                  current_setting('active_version.context', true)::jsonb,
+                  '{}'::jsonb
+                );
+
+                -- Insert audit record
+                IF TG_OP = 'DELETE' THEN
+                  INSERT INTO #{audit_table_name} (
+                    auditable_id,
+                    auditable_type,
+                    #{action_column},
+                    #{changes_column},
+                    #{version_column},
+                    #{context_column},
+                    created_at,
+                    updated_at
+                  ) VALUES (
+                    OLD.id,
+                    '#{auditable_type}',
+                    action_type,
+                    changes,
+                    new_version,
+                    context_data,
+                    NOW(),
+                    NOW()
+                  );
+                  RETURN OLD;
+                ELSE
+                  INSERT INTO #{audit_table_name} (
+                    auditable_id,
+                    auditable_type,
+                    #{action_column},
+                    #{changes_column},
+                    #{version_column},
+                    #{context_column},
+                    created_at,
+                    updated_at
+                  ) VALUES (
+                    NEW.id,
+                    '#{auditable_type}',
+                    action_type,
+                    changes,
+                    new_version,
+                    context_data,
+                    NOW(),
+                    NOW()
+                  );
+                  RETURN NEW;
+                END IF;
+              END;
+              $$ LANGUAGE plpgsql;
+            SQL
+          end
+
+          # Generate trigger for audits
+          # @param table_name [String] Name of the table
+          # @param options [Hash] Trigger options
+          # @return [String] SQL for CREATE TRIGGER statement
+          def generate_audit_trigger(table_name, options = {})
+            function_name = "active_version_audit_#{table_name}"
+            trigger_name = options[:trigger_name] || "active_version_audit_on_#{table_name}"
+            events = options[:events] || [:insert, :update, :delete]
+
+            event_clause = events.map(&:upcase).join(" OR ")
+
+            <<~SQL
+              CREATE TRIGGER #{trigger_name}
+              AFTER #{event_clause} ON #{table_name}
+              FOR EACH ROW
+              WHEN (coalesce(current_setting('active_version.disabled', true), '') <> 'on')
+              EXECUTE FUNCTION #{function_name}();
+            SQL
+          end
+
+          # Generate trigger function for revisions
+          # @param table_name [String] Name of the table
+          # @param revision_table_name [String] Name of the revision table
+          # @param options [Hash] Trigger options
+          # @return [String] SQL for trigger function
+          def generate_revision_trigger_function(table_name, revision_table_name, options = {})
+            function_name = "active_version_revision_#{table_name}"
+            foreign_key = options[:foreign_key] || "#{table_name.singularize}_id"
+            version_column = options[:version_column] || "version"
+
+            <<~SQL
+              CREATE OR REPLACE FUNCTION #{function_name}()
+              RETURNS TRIGGER AS $$
+              DECLARE
+                new_version INTEGER;
+                revision_data RECORD;
+              BEGIN
+                -- Only create revision on UPDATE
+                IF TG_OP != 'UPDATE' THEN
+                  RETURN NEW;
+                END IF;
+
+                -- Skip if nothing changed
+                IF NEW.* IS NOT DISTINCT FROM OLD.* THEN
+                  RETURN NEW;
+                END IF;
+
+                -- Get next version number
+                SELECT COALESCE(MAX(#{version_column}), 0) + 1
+                INTO new_version
+                FROM #{revision_table_name}
+                WHERE #{revision_table_name}.#{foreign_key} = NEW.id;
+
+                -- Create revision with OLD values
+                INSERT INTO #{revision_table_name} (
+                  #{foreign_key},
+                  #{version_column},
+                  #{build_revision_columns(table_name, options)},
+                  created_at,
+                  updated_at
+                )
+                SELECT
+                  NEW.id,
+                  new_version,
+                  #{build_revision_values("OLD", table_name, options)},
+                  NOW(),
+                  NOW();
+
+                RETURN NEW;
+              END;
+              $$ LANGUAGE plpgsql;
+            SQL
+          end
+
+          # Generate trigger for revisions
+          # @param table_name [String] Name of the table
+          # @param options [Hash] Trigger options
+          # @return [String] SQL for CREATE TRIGGER statement
+          def generate_revision_trigger(table_name, options = {})
+            function_name = "active_version_revision_#{table_name}"
+            trigger_name = options[:trigger_name] || "active_version_revision_on_#{table_name}"
+
+            <<~SQL
+              CREATE TRIGGER #{trigger_name}
+              BEFORE UPDATE ON #{table_name}
+              FOR EACH ROW
+              WHEN (coalesce(current_setting('active_version.disabled', true), '') <> 'on')
+              EXECUTE FUNCTION #{function_name}();
+            SQL
+          end
+
+          # Drop trigger function
+          # @param function_name [String] Name of the function
+          # @return [String] SQL for DROP FUNCTION statement
+          def drop_trigger_function(function_name)
+            "DROP FUNCTION IF EXISTS #{function_name}() CASCADE;"
+          end
+
+          # Drop trigger
+          # @param trigger_name [String] Name of the trigger
+          # @param table_name [String] Name of the table
+          # @return [String] SQL for DROP TRIGGER statement
+          def drop_trigger(trigger_name, table_name)
+            "DROP TRIGGER IF EXISTS #{trigger_name} ON #{table_name} CASCADE;"
+          end
+
+          private
+
+          def build_revision_columns(table_name, options)
+            columns = normalize_revision_columns(options)
+            columns.join(", ")
+          end
+
+          def build_revision_values(record_prefix, table_name, options)
+            columns = normalize_revision_columns(options)
+            columns.map { |column| "#{record_prefix}.#{column}" }.join(", ")
+          end
+
+          def normalize_revision_columns(options)
+            raw_columns = Array(options[:columns]).map(&:to_s)
+            if raw_columns.empty?
+              raise ArgumentError, "revision trigger generation requires :columns option"
+            end
+
+            foreign_key = options[:foreign_key].to_s
+            version_column = options[:version_column].to_s
+            metadata_columns = [foreign_key, version_column, "id", "created_at", "updated_at"]
+            raw_columns.reject { |col| metadata_columns.include?(col) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_version/database.rb

@@ -0,0 +1,7 @@
+require "active_version/database/triggers/postgresql"
+
+module ActiveVersion
+  module Database
+    # Database utilities for ActiveVersion
+  end
+end

data/lib/active_version/instrumentation.rb

@@ -0,0 +1,226 @@
+module ActiveVersion
+  # Instrumentation for ActiveSupport::Notifications
+  module Instrumentation
+    EVENTS = {
+      translation_created: "translation_created.active_version",
+      translation_updated: "translation_updated.active_version",
+      translation_destroyed: "translation_destroyed.active_version",
+      translation_fallback_used: "translation_fallback_used.active_version",
+      revision_created: "revision.active_version",
+      revision_reverted: "revision_reverted.active_version",
+      revision_switch_applied: "revision_switch_applied.active_version",
+      revision_write_failed: "revision_write_failed.active_version",
+      audit_created: "audit.active_version",
+      audit_write_failed: "audit_write_failed.active_version",
+      audit_sql_generated: "audit_sql.active_version"
+    }.freeze
+
+    class << self
+      # Instrument a translation creation
+      def instrument_translation_created(translation, source)
+        instrument_event(:translation_created) do
+          {
+            translation: translation,
+            source: source,
+            locale: translation.locale
+          }
+        end
+      end
+
+      # Instrument a translation update
+      def instrument_translation_updated(translation, source)
+        instrument_event(:translation_updated) do
+          {
+            translation: translation,
+            source: source,
+            locale: translation.locale
+          }
+        end
+      end
+
+      # Instrument a translation destroy
+      def instrument_translation_destroyed(translation, source)
+        instrument_event(:translation_destroyed) do
+          {
+            translation: translation,
+            source: source,
+            locale: translation.locale,
+            translation_id: translation.id
+          }
+        end
+      end
+
+      # Instrument when translation falls back from requested locale
+      def instrument_translation_fallback_used(source, attr:, requested_locale:, resolved_locale:)
+        instrument_event(:translation_fallback_used) do
+          {
+            source: source,
+            attr: attr,
+            requested_locale: requested_locale,
+            resolved_locale: resolved_locale
+          }
+        end
+      end
+
+      # Instrument a revision creation
+      def instrument_revision_created(revision, source)
+        source_class = source&.class
+        source_class ||= revision.class.source_class if revision.class.respond_to?(:source_class)
+        version_value = nil
+
+        if source_class
+          version_column = ActiveVersion.column_mapper.column_for(source_class, :revisions, :version)
+          version_value = if revision.respond_to?(version_column)
+            revision.public_send(version_column)
+          else
+            revision[version_column]
+          end
+        else
+          version_value = revision[ActiveVersion.config.revision_version_column] if revision.respond_to?(:[])
+          version_value ||= revision.version if revision.respond_to?(:version)
+        end
+
+        instrument_event(:revision_created) do
+          {
+            revision: revision,
+            source: source,
+            version: version_value
+          }
+        end
+      rescue NameError
+        instrument_event(:revision_created) do
+          {
+            revision: revision,
+            source: source,
+            version: nil
+          }
+        end
+      end
+
+      # Instrument revision revert action
+      def instrument_revision_reverted(source, from_version:, to_version:, strategy: :revert_to)
+        instrument_event(:revision_reverted) do
+          {
+            source: source,
+            from_version: from_version,
+            to_version: to_version,
+            strategy: strategy
+          }
+        end
+      end
+
+      # Instrument revision pointer switch action
+      def instrument_revision_switch_applied(source, from_version:, to_version:, append:)
+        instrument_event(:revision_switch_applied) do
+          {
+            source: source,
+            from_version: from_version,
+            to_version: to_version,
+            append: append
+          }
+        end
+      end
+
+      # Instrument revision write failures
+      def instrument_revision_write_failed(source, error:)
+        instrument_event(:revision_write_failed) do
+          {
+            source: source,
+            error: format_error(error)
+          }
+        end
+      end
+
+      # Instrument an audit creation
+      def instrument_audit_created(audit, auditable)
+        source_class = auditable&.class
+        source_class ||= audit.class.source_class if audit.class.respond_to?(:source_class)
+        version_value = nil
+
+        if source_class
+          version_column = ActiveVersion.column_mapper.column_for(source_class, :audits, :version)
+          version_value = if audit.respond_to?(version_column)
+            audit.public_send(version_column)
+          else
+            audit[version_column]
+          end
+        else
+          version_value = audit[ActiveVersion.config.audit_version_column] if audit.respond_to?(:[])
+          version_value ||= audit.version if audit.respond_to?(:version)
+        end
+
+        instrument_event(:audit_created) do
+          {
+            audit: audit,
+            auditable: auditable,
+            action: audit.action,
+            version: version_value
+          }
+        end
+      rescue NameError
+        instrument_event(:audit_created) do
+          {
+            audit: audit,
+            auditable: auditable,
+            action: audit.action,
+            version: nil
+          }
+        end
+      end
+
+      # Instrument audit write failures
+      def instrument_audit_write_failed(source, error:, action:)
+        instrument_event(:audit_write_failed) do
+          {
+            source: source,
+            action: action,
+            error: format_error(error)
+          }
+        end
+      end
+
+      # Instrument SQL generation
+      def instrument_audit_sql_generated(model, sql)
+        instrument_event(:audit_sql_generated) do
+          {
+            model: model,
+            sql: sql
+          }
+        end
+      end
+
+      private
+
+      def instrument_event(event_key)
+        event_name = EVENTS[event_key]
+        return unless event_name
+        return unless listening?(event_name)
+
+        payload = block_given? ? yield : {}
+        ActiveSupport::Notifications.instrument(event_name, payload)
+      end
+
+      def listening?(event_name)
+        ActiveSupport::Notifications.notifier.listening?(event_name)
+      rescue => e
+        log_debug("listener probe failed for #{event_name}: #{e.class}: #{e.message}; assuming listeners may exist")
+        true
+      end
+
+      def format_error(error)
+        return nil if error.nil?
+
+        {
+          class: error.class.name,
+          message: error.message
+        }
+      end
+
+      def log_debug(message)
+        if defined?(Rails) && Rails.respond_to?(:logger)
+          Rails.logger&.debug("[ActiveVersion::Instrumentation] #{message}")
+        end
+      end
+    end
+  end
+end

data/lib/active_version/migrators/audited.rb

@@ -0,0 +1,84 @@
+require "active_version/migrators/base"
+
+module ActiveVersion
+  module Migrators
+    # Migrator from audited gem
+    class Audited < Base
+      class << self
+        # Migrate audits from audited gem
+        # @param model_class [Class] ActiveRecord model class
+        # @param options [Hash] Migration options
+        # @option options [Boolean] :dry_run (false) Don't actually migrate
+        # @return [Integer] Number of records migrated
+        def migrate(model_class, options = {})
+          return 0 unless model_class.respond_to?(:audited?)
+
+          audit_class = model_class.audit_class
+          return 0 unless audit_class
+
+          old_audits = source_audits(model_class)
+          count = 0
+
+          if old_audits.respond_to?(:find_each)
+            old_audits.find_each do |old_audit|
+              count += 1
+              next if options[:dry_run]
+
+              audit_data = convert_audit(old_audit, model_class)
+              create_audit(nil, audit_data, audit_class)
+            end
+          else
+            # Handle array case (from mocked source_audits in tests)
+            old_audits.each do |old_audit|
+              count += 1
+              next if options[:dry_run]
+
+              audit_data = convert_audit(old_audit, model_class)
+              create_audit(nil, audit_data, audit_class)
+            end
+          end
+
+          count
+        end
+
+        private
+
+        def source_audits(model_class)
+          # Try to find old audit class
+          old_audit_class = if defined?(::Audited::Audit)
+            ::Audited::Audit
+          else
+            begin
+              "#{model_class.name}Audit".constantize
+            rescue
+              nil
+            end
+          end
+
+          return [] unless old_audit_class
+
+          old_audit_class.where(auditable_type: model_class.name)
+        end
+
+        def convert_audit(old_audit, model_class)
+          auditable_column = ActiveVersion.column_mapper.column_for(model_class, :audits, :auditable).to_s
+          version_column = ActiveVersion.column_mapper.column_for(model_class, :audits, :version).to_s
+          changes_column = ActiveVersion.column_mapper.column_for(model_class, :audits, :changes).to_s
+          context_column = ActiveVersion.column_mapper.column_for(model_class, :audits, :context).to_s
+          comment_column = ActiveVersion.column_mapper.column_for(model_class, :audits, :comment).to_s
+
+          {
+            "#{auditable_column}_id" => old_audit.auditable_id,
+            "#{auditable_column}_type" => old_audit.auditable_type,
+            version_column => old_audit.version,
+            changes_column => old_audit.audited_changes,
+            context_column => (old_audit.respond_to?(:audited_context) ? old_audit.audited_context : {}),
+            comment_column => old_audit.comment,
+            :created_at => old_audit.created_at,
+            :updated_at => old_audit.updated_at || old_audit.created_at
+          }
+        end
+      end
+    end
+  end
+end