pg_sql_triggers 1.3.0 → 1.5.0

data/lib/pg_sql_triggers/testing/function_tester.rb

@@ -7,122 +7,60 @@ module PgSqlTriggers
         @trigger = trigger_registry
       end
 
-      # Test ONLY the function, not the trigger
-      # rubocop:disable Lint/UnusedMethodArgument
+      FUNCTION_NAME_PATTERN = /CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/i
+
+      # Test ONLY the function, not the trigger.
+      #
+      # +test_context+ is accepted for API compatibility with future invocation logic.
+      # It is normalised to an empty hash when +nil+ so callers can pass either.
       def test_function_only(test_context: {})
+        test_context ||= {}
         results = {
           function_created: false,
           function_executed: false,
           errors: [],
-          output: []
+          output: [],
+          context: test_context
         }
 
-        # Check if function_body is present
-        if @trigger.function_body.blank?
-          results[:success] = false
-          results[:errors] << "Function body is missing"
-          return results
+        return fail_result(results, "Function body is missing") if @trigger.function_body.blank?
+        unless extract_function_name_from_body
+          return fail_result(results, "Function body does not contain a valid CREATE FUNCTION statement")
         end
 
-        # Extract function name to verify it matches
-        function_name_from_body = nil
-        if @trigger.function_body.present?
-          pattern = /CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/i
-          match = @trigger.function_body.match(pattern)
-          function_name_from_body = match[1] if match
-        end
+        run_function_test_transaction(results)
+        results[:output] << "\n⚠ Function rolled back (test mode)"
+        results
+      end
 
-        # If function_body doesn't contain a valid function definition, fail early
-        unless function_name_from_body
-          results[:success] = false
-          results[:errors] << "Function body does not contain a valid CREATE FUNCTION statement"
-          return results
-        end
+      private
+
+      def fail_result(results, error_message)
+        results[:success] = false
+        results[:errors] << error_message
+        results
+      end
+
+      def extract_function_name_from_body
+        return nil if @trigger.function_body.blank?
+
+        match = @trigger.function_body.match(FUNCTION_NAME_PATTERN)
+        match && match[1]
+      end
+
+      def extract_function_name_from_definition
+        return nil if @trigger.definition.blank?
+
+        definition = JSON.parse(@trigger.definition)
+        definition["function_name"] || definition["name"]
+      rescue StandardError
+        nil
+      end
 
-        # rubocop:disable Metrics/BlockLength
+      def run_function_test_transaction(results)
         ActiveRecord::Base.transaction do
-          # Create function in transaction
-          begin
-            ActiveRecord::Base.connection.execute(@trigger.function_body)
-            results[:function_created] = true
-            results[:output] << "✓ Function created in test transaction"
-          rescue ActiveRecord::StatementInvalid, StandardError => e
-            results[:success] = false
-            results[:errors] << "Error during function creation: #{e.message}"
-            # Don't raise here, let it fall through to ensure block for rollback
-          end
-
-          # Try to invoke function directly (if test context provided)
-          # Note: Empty hash {} is not "present" in Rails, so check if it's not nil
-          if results[:function_created]
-            # This would require custom invocation logic
-            # For now, just verify it was created - if function was successfully created,
-            # we can assume it exists and is executable within the transaction
-            function_name = nil
-
-            # First, try to extract from function_body (most reliable)
-            if @trigger.function_body.present?
-              # Extract function name from CREATE FUNCTION statement
-              # Match: CREATE [OR REPLACE] FUNCTION function_name(...)
-              pattern = /CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(/i
-              match = @trigger.function_body.match(pattern)
-              function_name = match[1] if match
-            end
-
-            # Fallback to definition JSON if function_body extraction failed
-            if function_name.blank? && @trigger.definition.present?
-              definition = begin
-                JSON.parse(@trigger.definition)
-              rescue StandardError
-                {}
-              end
-              function_name = definition["function_name"] || definition[:function_name] ||
-                              definition["name"] || definition[:name]
-            end
-
-            # Verify function exists in database by checking pg_proc
-            # Try to verify via query if function_name is available
-            if function_name.present?
-              begin
-                sanitized_name = begin
-                  ActiveRecord::Base.connection.quote_string(function_name)
-                rescue StandardError => e
-                  # If quote_string fails, use the function name as-is (less safe but allows test to continue)
-                  results[:errors] << "Error during function name sanitization: #{e.message}"
-                  function_name
-                end
-                check_sql = <<~SQL.squish
-                  SELECT COUNT(*) as count
-                  FROM pg_proc p
-                  JOIN pg_namespace n ON p.pronamespace = n.oid
-                  WHERE p.proname = '#{sanitized_name}'
-                  AND n.nspname = 'public'
-                SQL
-
-                result = ActiveRecord::Base.connection.execute(check_sql).first
-                results[:function_executed] = result && result["count"].to_i.positive?
-                results[:output] << if results[:function_executed]
-                                      "✓ Function exists and is callable"
-                                    else
-                                      "✓ Function created (verified via successful creation)"
-                                    end
-              rescue ActiveRecord::StatementInvalid, StandardError => e
-                results[:function_executed] = false
-                results[:success] = false
-                results[:errors] << "Error during function verification: #{e.message}"
-                # Also add the original error message to ensure it's searchable in tests
-                results[:errors] << e.message unless results[:errors].include?(e.message)
-                results[:output] << "✓ Function created (verification failed)"
-              end
-            else
-              # If we can't extract function name, assume it was created successfully
-              # since function_created is true
-              results[:function_executed] = true
-              results[:output] << "✓ Function created (execution verified via successful creation)"
-            end
-          end
-
-          # Set success to true only if no errors occurred and function was created
+          create_function_in_transaction(results)
+          verify_function_in_transaction(results) if results[:function_created]
           results[:success] = results[:errors].empty? && results[:function_created]
         rescue ActiveRecord::StatementInvalid, StandardError => e
           results[:success] = false
@@ -130,11 +68,63 @@ module PgSqlTriggers
         ensure
           raise ActiveRecord::Rollback
         end
+      end
 
-        results[:output] << "\n⚠ Function rolled back (test mode)"
-        results
+      def create_function_in_transaction(results)
+        ActiveRecord::Base.connection.execute(@trigger.function_body)
+        results[:function_created] = true
+        results[:output] << "✓ Function created in test transaction"
+      rescue ActiveRecord::StatementInvalid, StandardError => e
+        results[:success] = false
+        results[:errors] << "Error during function creation: #{e.message}"
+      end
+
+      def verify_function_in_transaction(results)
+        function_name = extract_function_name_from_body || extract_function_name_from_definition
+
+        if function_name.blank?
+          results[:function_executed] = true
+          results[:output] << "✓ Function created (execution verified via successful creation)"
+          return
+        end
+
+        verify_function_in_pg_proc(function_name, results)
       end
-      # rubocop:enable Lint/UnusedMethodArgument, Metrics/BlockLength
+
+      def verify_function_in_pg_proc(function_name, results)
+        sanitized_name = safe_quote_function_name(function_name, results)
+        check_sql = <<~SQL.squish
+          SELECT COUNT(*) as count
+          FROM pg_proc p
+          JOIN pg_namespace n ON p.pronamespace = n.oid
+          WHERE p.proname = '#{sanitized_name}'
+          AND n.nspname = 'public'
+        SQL
+
+        result = ActiveRecord::Base.connection.execute(check_sql).first
+        results[:function_executed] = result && result["count"].to_i.positive?
+        results[:output] << if results[:function_executed]
+                              "✓ Function exists and is callable"
+                            else
+                              "✓ Function created (verified via successful creation)"
+                            end
+      rescue ActiveRecord::StatementInvalid, StandardError => e
+        results[:function_executed] = false
+        results[:success] = false
+        results[:errors] << "Error during function verification: #{e.message}"
+        results[:errors] << e.message unless results[:errors].include?(e.message)
+        results[:output] << "✓ Function created (verification failed)"
+      end
+
+      def safe_quote_function_name(function_name, results)
+        ActiveRecord::Base.connection.quote_string(function_name)
+      rescue StandardError => e
+        # If quote_string fails, use the function name as-is (less safe but allows test to continue)
+        results[:errors] << "Error during function name sanitization: #{e.message}"
+        function_name
+      end
+
+      public
 
       # Check if function already exists in database
       def function_exists?

data/lib/pg_sql_triggers/trigger_structure_dumper.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "time"
+
+module PgSqlTriggers
+  # Builds a SQL snapshot of PostgreSQL triggers for db/trigger_structure.sql and
+  # emits schema.rb annotations so teams know triggers are outside schema.rb.
+  class TriggerStructureDumper
+    class << self
+      def resolve_path(override = nil)
+        base = override || PgSqlTriggers.trigger_structure_sql_path
+        resolved = base.respond_to?(:call) ? base.call : base
+        resolved ||= default_path
+        Pathname(resolved.to_s)
+      end
+
+      def default_path
+        raise "Rails.root is required" unless defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+
+        Rails.root.join("db/trigger_structure.sql")
+      end
+
+      def dump_to(path = nil, connection: ActiveRecord::Base.connection)
+        target = resolve_path(path)
+        target.dirname.mkpath
+        target.write(generate_sql(connection: connection))
+        target
+      end
+
+      def load_from(path = nil, connection: ActiveRecord::Base.connection)
+        target = resolve_path(path)
+        raise Errno::ENOENT, target.to_s unless target.file?
+
+        sql = target.read
+        return if sql.strip.empty?
+
+        connection.raw_connection.exec(sql)
+        nil
+      end
+
+      def generate_sql(connection: ActiveRecord::Base.connection)
+        header = <<~SQL
+          -- pg_sql_triggers trigger_structure.sql
+          -- Generated at: #{Time.now.utc.iso8601}
+          --
+          -- Apply with: bin/rails trigger:load
+          -- Prefer checking this file into version control alongside db/triggers migrations.
+        SQL
+
+        rows = trigger_rows(connection)
+        parts = [header]
+
+        rows.each do |row|
+          trigger_name = row["trigger_name"] || row[:trigger_name]
+          parts << ""
+          parts << "-- Trigger: #{trigger_name}"
+          append_definition(parts, row["function_definition"] || row[:function_definition])
+          append_definition(parts, row["trigger_definition"] || row[:trigger_definition])
+        end
+
+        parts.join("\n").strip.concat("\n")
+      end
+
+      def schema_rb_annotation(connection: ActiveRecord::Base.connection)
+        names = managed_trigger_names(connection)
+        lines = []
+        lines << "  # ---------------------------------------------------------------------------"
+        lines << "  # pg_sql_triggers: PostgreSQL triggers are not captured in schema.rb."
+        lines << "  # After db:schema:load, run: bin/rails trigger:migrate (or trigger:load)."
+        lines << "  # SQL snapshot: db/trigger_structure.sql (bin/rails trigger:dump)."
+        lines << "  # For full fidelity use config.active_record.schema_format = :sql."
+        lines << if names.any?
+                   "  # Managed triggers (#{names.length}): #{names.join(', ')}"
+                 else
+                   "  # Managed triggers: (none registered in pg_sql_triggers_registry)"
+                 end
+        lines << "  # ---------------------------------------------------------------------------"
+        lines.join("\n")
+      end
+
+      def managed_trigger_names(connection)
+        return [] unless connection.table_exists?("pg_sql_triggers_registry")
+
+        connection.select_values(
+          "SELECT trigger_name FROM pg_sql_triggers_registry ORDER BY trigger_name"
+        )
+      end
+
+      private
+
+      def trigger_rows(connection)
+        if connection.table_exists?("pg_sql_triggers_registry")
+          managed_trigger_names(connection).filter_map do |name|
+            PgSqlTriggers::Drift::DbQueries.find_trigger(name)
+          end
+        else
+          PgSqlTriggers::Drift::DbQueries.all_triggers
+        end
+      end
+
+      def append_definition(parts, definition)
+        stmt = definition.to_s.strip
+        return if stmt.empty?
+
+        stmt += ";" unless stmt.end_with?(";")
+        parts << stmt
+      end
+    end
+  end
+end

data/lib/pg_sql_triggers/version.rb

@@ -11,5 +11,5 @@
 # 3. Run: bundle exec rake release
 # See RELEASE.md for detailed release instructions
 module PgSqlTriggers
-  VERSION = "1.3.0"
+  VERSION = "1.5.0"
 end

data/lib/pg_sql_triggers.rb

@@ -36,6 +36,24 @@ module PgSqlTriggers
   mattr_accessor :allow_unsafe_migrations
   self.allow_unsafe_migrations = false
 
+  # Path or callable returning path for trigger SQL snapshot (default: db/trigger_structure.sql).
+  mattr_accessor :trigger_structure_sql_path
+
+  mattr_accessor :append_trigger_notes_to_schema_dump
+  self.append_trigger_notes_to_schema_dump = true
+
+  mattr_accessor :migrate_triggers_after_schema_load
+  self.migrate_triggers_after_schema_load = true
+
+  # PostgreSQL schema used by DbQueries. Override for non-public schemas.
+  mattr_accessor :db_schema
+  self.db_schema = "public"
+
+  # Callable invoked when drift check finds drifted, dropped, or unknown triggers (+nil+ = no-op).
+  # See {PgSqlTriggers::Alerting.check_and_notify} and +trigger:check_drift+.
+  mattr_accessor :drift_notifier
+  self.drift_notifier = nil
+
   # Drift states
   DRIFT_STATE_IN_SYNC = "in_sync"
   DRIFT_STATE_DRIFTED = "drifted"
@@ -55,8 +73,10 @@ module PgSqlTriggers
   autoload :Permissions, "pg_sql_triggers/permissions"
   autoload :SQL, "pg_sql_triggers/sql"
   autoload :DatabaseIntrospection, "pg_sql_triggers/database_introspection"
-  autoload :Generator, "pg_sql_triggers/generator"
   autoload :Testing, "pg_sql_triggers/testing"
   autoload :Migration, "pg_sql_triggers/migration"
   autoload :Migrator, "pg_sql_triggers/migrator"
+  autoload :DeferralChecksum, "pg_sql_triggers/deferral_checksum"
+  autoload :EventsChecksum, "pg_sql_triggers/events_checksum"
+  autoload :Alerting, "pg_sql_triggers/alerting"
 end