pg_sql_triggers 1.0.0 → 1.0.1

data/lib/pg_sql_triggers/sql/kill_switch.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+module PgSqlTriggers
+  module SQL
+    # KillSwitch is a centralized safety gate that prevents dangerous operations
+    # from being executed in protected environments (typically production).
+    #
+    # It operates on three levels:
+    # 1. Configuration Level: Environment-based activation via PgSqlTriggers.kill_switch_enabled
+    # 2. Runtime Level: ENV variable override support (KILL_SWITCH_OVERRIDE)
+    # 3. Explicit Confirmation Level: Typed confirmation text for critical operations
+    #
+    # @example Basic usage in a dangerous operation
+    #   KillSwitch.check!(
+    #     operation: :migrate_up,
+    #     environment: Rails.env,
+    #     confirmation: params[:confirmation_text],
+    #     actor: { type: 'UI', id: current_user.email }
+    #   )
+    #
+    # @example Using override block
+    #   KillSwitch.override(confirmation: "EXECUTE MIGRATE_UP") do
+    #     # dangerous operation here
+    #   end
+    #
+    # @example CLI usage with ENV override
+    #   KILL_SWITCH_OVERRIDE=true CONFIRMATION_TEXT="EXECUTE MIGRATE_UP" rake pg_sql_triggers:migrate
+    #
+    # rubocop:disable Metrics/ModuleLength
+    module KillSwitch
+      # Thread-local storage key for override state
+      OVERRIDE_KEY = :pg_sql_triggers_kill_switch_override
+
+      class << self
+        # Checks if the kill switch is active for the given environment and operation.
+        #
+        # @param environment [String, Symbol, nil] The environment to check (defaults to current environment)
+        # @param operation [String, Symbol, nil] The operation being performed (for logging)
+        # @return [Boolean] true if kill switch is active, false otherwise
+        def active?(environment: nil, operation: nil)
+          # Check if kill switch is globally disabled
+          return false unless kill_switch_enabled?
+
+          # Detect environment
+          env = detect_environment(environment)
+
+          # Check if this environment is protected
+          is_active = protected_environment?(env)
+
+          # Log the check if logger is available and operation is provided
+          if logger && operation
+            logger.debug "[KILL_SWITCH] Check: operation=#{operation} environment=#{env} active=#{is_active}"
+          end
+
+          is_active
+        end
+
+        # Checks if an operation should be blocked by the kill switch.
+        # Raises KillSwitchError if the operation is blocked.
+        #
+        # @param operation [String, Symbol] The operation being performed
+        # @param environment [String, Symbol, nil] The environment (defaults to current)
+        # @param confirmation [String, nil] The confirmation text provided by the user
+        # @param actor [Hash, nil] Information about who is performing the operation
+        # @raise [PgSqlTriggers::KillSwitchError] if the operation is blocked
+        # @return [void]
+        def check!(operation:, environment: nil, confirmation: nil, actor: nil)
+          env = detect_environment(environment)
+
+          # Check if kill switch is active for this environment
+          unless active?(environment: env, operation: operation)
+            log_allowed(operation: operation, environment: env, actor: actor, reason: "not_protected_environment")
+            return
+          end
+
+          # Check for thread-local override
+          if thread_override_active?
+            log_override(operation: operation, environment: env, actor: actor, source: "thread_local")
+            return
+          end
+
+          # Check for ENV override
+          if env_override_active?
+            # If ENV override is present, check confirmation if required
+            if confirmation_required?
+              validate_confirmation!(confirmation, operation)
+              log_override(operation: operation, environment: env, actor: actor, source: "env_with_confirmation",
+                           confirmation: confirmation)
+            else
+              log_override(operation: operation, environment: env, actor: actor, source: "env_without_confirmation")
+            end
+            return
+          end
+
+          # If confirmation is provided, validate it
+          unless confirmation.nil?
+            validate_confirmation!(confirmation, operation)
+            log_override(operation: operation, environment: env, actor: actor, source: "explicit_confirmation",
+                         confirmation: confirmation)
+            return
+          end
+
+          # No override mechanism satisfied - block the operation
+          log_blocked(operation: operation, environment: env, actor: actor)
+          raise_blocked_error(operation: operation, environment: env)
+        end
+
+        # Temporarily overrides the kill switch for the duration of the block.
+        # Uses thread-local storage to ensure thread safety.
+        #
+        # @param confirmation [String, nil] Optional confirmation text
+        # @yield The block to execute with kill switch overridden
+        # @return The return value of the block
+        def override(confirmation: nil)
+          raise ArgumentError, "Block required for kill switch override" unless block_given?
+
+          # Validate confirmation if provided and required
+          if confirmation.present? && confirmation_required?
+            # NOTE: We can't validate against a specific operation here since we don't know it
+            # The block itself will call check! with the operation, which will see the override
+            logger&.info "[KILL_SWITCH] Override block initiated with confirmation: #{confirmation}"
+          end
+
+          # Set thread-local override
+          previous_value = Thread.current[OVERRIDE_KEY]
+          Thread.current[OVERRIDE_KEY] = true
+
+          begin
+            yield
+          ensure
+            # Restore previous value
+            Thread.current[OVERRIDE_KEY] = previous_value
+          end
+        end
+
+        # Validates the confirmation text against the expected pattern for the operation.
+        #
+        # @param confirmation [String, nil] The confirmation text to validate
+        # @param operation [String, Symbol] The operation being confirmed
+        # @raise [PgSqlTriggers::KillSwitchError] if confirmation is invalid
+        # @return [void]
+        def validate_confirmation!(confirmation, operation)
+          expected = expected_confirmation(operation)
+
+          if confirmation.nil? || confirmation.strip.empty?
+            raise PgSqlTriggers::KillSwitchError,
+                  "Confirmation text required. Expected: '#{expected}'"
+          end
+
+          return if confirmation.strip == expected
+
+          raise PgSqlTriggers::KillSwitchError,
+                "Invalid confirmation text. Expected: '#{expected}', got: '#{confirmation.strip}'"
+        end
+
+        private
+
+        # Checks if kill switch is globally enabled in configuration
+        def kill_switch_enabled?
+          return true unless PgSqlTriggers.respond_to?(:kill_switch_enabled)
+
+          # Default to true (fail-safe) if not configured
+          value = PgSqlTriggers.kill_switch_enabled
+          value.nil? || value
+        end
+
+        # Checks if the given environment is protected by the kill switch
+        def protected_environment?(environment)
+          return false if environment.nil?
+
+          protected_envs = if PgSqlTriggers.respond_to?(:kill_switch_environments)
+                             value = PgSqlTriggers.kill_switch_environments
+                             value.nil? ? %i[production staging] : value
+                           else
+                             %i[production staging]
+                           end
+
+          protected_envs = Array(protected_envs).map(&:to_s)
+          protected_envs.include?(environment.to_s)
+        end
+
+        # Detects the current environment
+        def detect_environment(environment)
+          return environment.to_s if environment.present?
+
+          # Try Rails environment
+          return Rails.env.to_s if defined?(Rails) && Rails.respond_to?(:env)
+
+          # Try PgSqlTriggers default_environment
+          if PgSqlTriggers.respond_to?(:default_environment) && PgSqlTriggers.default_environment.respond_to?(:call)
+            begin
+              return PgSqlTriggers.default_environment.call.to_s
+            rescue NameError, NoMethodError # rubocop:disable Lint/ShadowedException
+              # Fall through to next option if default_environment proc references undefined constants
+            end
+          end
+
+          # Fall back to RAILS_ENV or RACK_ENV
+          ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+        end
+
+        # Checks if thread-local override is active
+        def thread_override_active?
+          Thread.current[OVERRIDE_KEY] == true
+        end
+
+        # Checks if ENV override is active
+        def env_override_active?
+          ENV["KILL_SWITCH_OVERRIDE"]&.downcase == "true"
+        end
+
+        # Checks if confirmation is required for overrides
+        def confirmation_required?
+          return true unless PgSqlTriggers.respond_to?(:kill_switch_confirmation_required)
+
+          # Default to true (safer) if not configured
+          value = PgSqlTriggers.kill_switch_confirmation_required
+          value.nil? || value
+        end
+
+        # Generates the expected confirmation text for an operation
+        def expected_confirmation(operation)
+          if PgSqlTriggers.respond_to?(:kill_switch_confirmation_pattern) &&
+             PgSqlTriggers.kill_switch_confirmation_pattern.respond_to?(:call)
+            PgSqlTriggers.kill_switch_confirmation_pattern.call(operation)
+          else
+            # Default pattern
+            "EXECUTE #{operation.to_s.upcase}"
+          end
+        end
+
+        # Returns the configured logger
+        def logger
+          if PgSqlTriggers.respond_to?(:kill_switch_logger)
+            PgSqlTriggers.kill_switch_logger
+          elsif defined?(Rails) && Rails.respond_to?(:logger)
+            Rails.logger
+          end
+        end
+
+        # Logs an allowed operation
+        def log_allowed(operation:, environment:, actor:, reason:)
+          actor_info = format_actor(actor)
+          logger&.info "[KILL_SWITCH] ALLOWED: operation=#{operation} environment=#{environment} " \
+                       "actor=#{actor_info} reason=#{reason}"
+        end
+
+        # Logs an overridden operation
+        def log_override(operation:, environment:, actor:, source:, confirmation: nil)
+          actor_info = format_actor(actor)
+          conf_info = confirmation ? " confirmation=#{confirmation}" : ""
+          logger&.warn "[KILL_SWITCH] OVERRIDDEN: operation=#{operation} environment=#{environment} " \
+                       "actor=#{actor_info} source=#{source}#{conf_info}"
+        end
+
+        # Logs a blocked operation
+        def log_blocked(operation:, environment:, actor:)
+          actor_info = format_actor(actor)
+          logger&.error "[KILL_SWITCH] BLOCKED: operation=#{operation} environment=#{environment} actor=#{actor_info}"
+        end
+
+        # Formats actor information for logging
+        def format_actor(actor)
+          return "unknown" if actor.nil?
+          return actor.to_s unless actor.is_a?(Hash)
+
+          "#{actor[:type] || 'unknown'}:#{actor[:id] || 'unknown'}"
+        end
+
+        # Raises a kill switch error with helpful message
+        def raise_blocked_error(operation:, environment:)
+          expected = expected_confirmation(operation)
+
+          message = <<~ERROR
+            Kill switch is active for #{environment} environment.
+            Operation '#{operation}' has been blocked for safety.
+
+            To override this protection, you must provide confirmation.
+
+            For CLI/rake tasks, use:
+              KILL_SWITCH_OVERRIDE=true CONFIRMATION_TEXT="#{expected}" rake your:task
+
+            For console operations, use:
+              PgSqlTriggers::SQL::KillSwitch.override(confirmation: "#{expected}") do
+                # your dangerous operation here
+              end
+
+            For UI operations, enter the confirmation text: #{expected}
+
+            This protection prevents accidental destructive operations in production.
+            Make sure you understand the implications before proceeding.
+          ERROR
+
+          raise PgSqlTriggers::KillSwitchError, message
+        end
+      end
+    end
+    # rubocop:enable Metrics/ModuleLength
+  end
+end

data/lib/pg_sql_triggers/testing/dry_run.rb

@@ -27,14 +27,12 @@ module PgSqlTriggers
         trigger_timing = "BEFORE" # Could be configurable
         trigger_level = "ROW"     # Could be configurable
 
-        trigger_sql = <<~SQL.squish
-          CREATE TRIGGER #{@trigger.trigger_name}
-          #{trigger_timing} #{events} ON #{@trigger.table_name}
-          FOR EACH #{trigger_level}
-        SQL
+        trigger_sql = "CREATE TRIGGER #{@trigger.trigger_name} " \
+                      "#{trigger_timing} #{events} ON #{@trigger.table_name} " \
+                      "FOR EACH #{trigger_level}"
 
-        trigger_sql += "WHEN (#{@trigger.condition})\n" if @trigger.condition.present?
-        trigger_sql += "EXECUTE FUNCTION #{definition['function_name']}();"
+        trigger_sql += " WHEN (#{@trigger.condition})" if @trigger.condition.present?
+        trigger_sql += " EXECUTE FUNCTION #{definition['function_name']}();"
 
         sql_parts << {
           type: "CREATE TRIGGER",

data/lib/pg_sql_triggers/testing/safe_executor.rb

@@ -26,21 +26,33 @@ module PgSqlTriggers
           end
 
           # Step 2: Create trigger
-          trigger_sql = DryRun.new(@trigger).generate_sql[:sql_parts]
-                              .find { |p| p[:type] == "CREATE TRIGGER" }[:sql]
-          ActiveRecord::Base.connection.execute(trigger_sql)
-          results[:trigger_created] = true
-          results[:output] << "✓ Trigger created successfully"
+          begin
+            sql_parts = DryRun.new(@trigger).generate_sql[:sql_parts]
+            trigger_part = sql_parts.find { |p| p[:type] == "CREATE TRIGGER" }
+            if trigger_part && trigger_part[:sql]
+              ActiveRecord::Base.connection.execute(trigger_part[:sql])
+              results[:trigger_created] = true
+              results[:output] << "✓ Trigger created successfully"
+            else
+              results[:errors] << "Could not find CREATE TRIGGER SQL in generated SQL parts"
+            end
+          rescue StandardError => e
+            results[:errors] << "Error generating trigger SQL: #{e.message}"
+          end
 
           # Step 3: Test with sample data (if provided)
-          if test_data
-            test_sql = build_test_insert(test_data)
-            ActiveRecord::Base.connection.execute(test_sql)
-            results[:test_insert_executed] = true
-            results[:output] << "✓ Test insert executed successfully"
+          if test_data && results[:trigger_created]
+            begin
+              test_sql = build_test_insert(test_data)
+              ActiveRecord::Base.connection.execute(test_sql)
+              results[:test_insert_executed] = true
+              results[:output] << "✓ Test insert executed successfully"
+            rescue StandardError => e
+              results[:errors] << "Error executing test insert: #{e.message}"
+            end
           end
 
-          results[:success] = true
+          results[:success] = results[:errors].empty?
         rescue ActiveRecord::StatementInvalid => e
           results[:success] = false
           results[:errors] << e.message

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.0.0"
+  VERSION = "1.0.1"
 end

data/lib/pg_sql_triggers.rb

@@ -14,6 +14,18 @@ module PgSqlTriggers
   mattr_accessor :kill_switch_enabled
   self.kill_switch_enabled = true
 
+  mattr_accessor :kill_switch_environments
+  self.kill_switch_environments = %i[production staging]
+
+  mattr_accessor :kill_switch_confirmation_required
+  self.kill_switch_confirmation_required = true
+
+  mattr_accessor :kill_switch_confirmation_pattern
+  self.kill_switch_confirmation_pattern = ->(operation) { "EXECUTE #{operation.to_s.upcase}" }
+
+  mattr_accessor :kill_switch_logger
+  self.kill_switch_logger = nil # Will default to Rails.logger if available
+
   mattr_accessor :default_environment
   self.default_environment = -> { Rails.env }
 

data/lib/tasks/trigger_migrations.rake

@@ -1,8 +1,23 @@
 # frozen_string_literal: true
 
+# Helper method to check kill switch before dangerous operations
+def check_kill_switch!(operation)
+  PgSqlTriggers::SQL::KillSwitch.check!(
+    operation: operation,
+    environment: Rails.env,
+    confirmation: ENV.fetch("CONFIRMATION_TEXT", nil),
+    actor: { type: "CLI", id: ENV.fetch("USER", "unknown") }
+  )
+rescue PgSqlTriggers::KillSwitchError => e
+  puts "\n#{e.message}\n"
+  exit 1
+end
+
 namespace :trigger do
   desc "Migrate trigger migrations (options: VERSION=x, VERBOSE=false)"
   task migrate: :environment do
+    check_kill_switch!(:trigger_migrate)
+
     PgSqlTriggers::Migrator.ensure_migrations_table!
 
     target_version = ENV["VERSION"]&.to_i
@@ -20,6 +35,8 @@ namespace :trigger do
 
   desc "Rollback trigger migrations (specify steps w/ STEP=n)"
   task rollback: :environment do
+    check_kill_switch!(:trigger_rollback)
+
     PgSqlTriggers::Migrator.ensure_migrations_table!
 
     steps = ENV["STEP"] ? ENV["STEP"].to_i : 1
@@ -64,6 +81,8 @@ namespace :trigger do
 
   desc "Runs the 'up' for a given migration VERSION"
   task "migrate:up" => :environment do
+    check_kill_switch!(:trigger_migrate_up)
+
     version = ENV.fetch("VERSION", nil)
     raise "VERSION is required" unless version
 
@@ -74,6 +93,8 @@ namespace :trigger do
 
   desc "Runs the 'down' for a given migration VERSION"
   task "migrate:down" => :environment do
+    check_kill_switch!(:trigger_migrate_down)
+
     version = ENV.fetch("VERSION", nil)
     raise "VERSION is required" unless version
 
@@ -84,6 +105,8 @@ namespace :trigger do
 
   desc "Rollbacks the database one migration and re migrate up (options: STEP=x, VERSION=x)"
   task "migrate:redo" => :environment do
+    check_kill_switch!(:trigger_migrate_redo)
+
     PgSqlTriggers::Migrator.ensure_migrations_table!
 
     if ENV["VERSION"]
@@ -127,6 +150,8 @@ end
 namespace :db do
   desc "Migrate the database schema and triggers (options: VERSION=x, VERBOSE=false)"
   task "migrate:with_triggers" => :environment do
+    check_kill_switch!(:db_migrate_with_triggers)
+
     verbose = ENV["VERBOSE"] != "false"
 
     puts "Running schema and trigger migrations..." if verbose
@@ -140,6 +165,8 @@ namespace :db do
 
   desc "Rollback schema and trigger migrations (specify steps w/ STEP=n)"
   task "rollback:with_triggers" => :environment do
+    check_kill_switch!(:db_rollback_with_triggers)
+
     ENV["STEP"] ? ENV["STEP"].to_i : 1
 
     # Determine which type of migration was last run
@@ -171,6 +198,8 @@ namespace :db do
 
   desc "Runs the 'up' for a given migration VERSION (schema or trigger)"
   task "migrate:up:with_triggers" => :environment do
+    check_kill_switch!(:db_migrate_up_with_triggers)
+
     version = ENV.fetch("VERSION", nil)
     raise "VERSION is required" unless version
 
@@ -201,6 +230,8 @@ namespace :db do
 
   desc "Runs the 'down' for a given migration VERSION (schema or trigger)"
   task "migrate:down:with_triggers" => :environment do
+    check_kill_switch!(:db_migrate_down_with_triggers)
+
     version = ENV.fetch("VERSION", nil)
     raise "VERSION is required" unless version
 
@@ -228,6 +259,8 @@ namespace :db do
 
   desc "Rollbacks the database one migration and re migrate up (options: STEP=x, VERSION=x)"
   task "migrate:redo:with_triggers" => :environment do
+    check_kill_switch!(:db_migrate_redo_with_triggers)
+
     if ENV["VERSION"]
       Rake::Task["db:migrate:down:with_triggers"].invoke
       Rake::Task["db:migrate:up:with_triggers"].invoke

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_sql_triggers
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - samaswin87
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-27 00:00:00.000000000 Z
+date: 2025-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: database_cleaner-active_record
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: erb_lint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: factory_bot_rails
   requirement: !ruby/object:Gem::Requirement
@@ -172,6 +186,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".erb_lint.yml"
 - ".rspec"
 - ".rubocop.yml"
 - CHANGELOG.md
@@ -193,10 +208,24 @@ files:
 - app/views/pg_sql_triggers/dashboard/index.html.erb
 - app/views/pg_sql_triggers/generator/new.html.erb
 - app/views/pg_sql_triggers/generator/preview.html.erb
+- app/views/pg_sql_triggers/shared/_confirmation_modal.html.erb
+- app/views/pg_sql_triggers/shared/_kill_switch_status.html.erb
 - app/views/pg_sql_triggers/tables/index.html.erb
 - app/views/pg_sql_triggers/tables/show.html.erb
 - config/routes.rb
 - db/migrate/20251222000001_create_pg_sql_triggers_tables.rb
+- docs/README.md
+- docs/api-reference.md
+- docs/configuration.md
+- docs/getting-started.md
+- docs/kill-switch.md
+- docs/screenshots/.gitkeep
+- docs/screenshots/Generate Trigger.png
+- docs/screenshots/Triggers Page.png
+- docs/screenshots/kill error.png
+- docs/screenshots/kill modal for migration down.png
+- docs/usage-guide.md
+- docs/web-ui.md
 - lib/generators/pg_sql_triggers/install_generator.rb
 - lib/generators/pg_sql_triggers/templates/README
 - lib/generators/pg_sql_triggers/templates/create_pg_sql_triggers_tables.rb
@@ -221,6 +250,7 @@ files:
 - lib/pg_sql_triggers/registry/manager.rb
 - lib/pg_sql_triggers/registry/validator.rb
 - lib/pg_sql_triggers/sql.rb
+- lib/pg_sql_triggers/sql/kill_switch.rb
 - lib/pg_sql_triggers/testing.rb
 - lib/pg_sql_triggers/testing/dry_run.rb
 - lib/pg_sql_triggers/testing/function_tester.rb
@@ -246,7 +276,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="