pg_sql_triggers 1.0.0

data/lib/pg_sql_triggers/generator/service.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "digest"
+require "active_support/core_ext/string/inflections"
+
+module PgSqlTriggers
+  module Generator
+    class Service
+      class << self
+        def generate_dsl(form)
+          # Generate DSL trigger definition
+          events_list = form.events.compact_blank.map { |e| ":#{e}" }.join(", ")
+          environments_list = form.environments.compact_blank.map { |e| ":#{e}" }.join(", ")
+
+          # Format function name (can be string or symbol)
+          function_ref = if form.function_name.to_s.match?(/\A[a-z0-9_]+\z/)
+                           ":#{form.function_name}"
+                         else
+                           "\"#{form.function_name}\""
+                         end
+
+          code = <<~RUBY
+            # frozen_string_literal: true
+
+            # Generated by pg_sql_triggers on #{Time.current.strftime('%Y-%m-%d %H:%M:%S')}
+            PgSqlTriggers::DSL.pg_sql_trigger "#{form.trigger_name}" do
+              table :#{form.table_name}
+              on #{events_list}
+              function #{function_ref}
+            #{'  '}
+              version #{form.version}
+              enabled #{form.enabled}
+          RUBY
+
+          code += "  when_env #{environments_list}\n" if form.environments.compact_blank.any?
+
+          code += "  when_condition \"#{form.condition.gsub('"', '\\"')}\"\n" if form.condition.present?
+
+          code += "end\n"
+
+          code
+        end
+
+        def generate_migration(form)
+          # Generate migration class code
+          # Use Rails migration naming convention: Add{TriggerName}
+          # This avoids Zeitwerk autoload conflicts with app/triggers files
+          class_name = "Add#{form.trigger_name.camelize}"
+          events_sql = form.events.compact_blank.map(&:upcase).join(" OR ")
+          function_body_sql = form.function_body.strip
+
+          # Build the trigger creation SQL
+          trigger_sql = "CREATE TRIGGER #{form.trigger_name}\n"
+          trigger_sql += "BEFORE #{events_sql} ON #{form.table_name}\n"
+          trigger_sql += "FOR EACH ROW\n"
+          trigger_sql += "WHEN (#{form.condition})\n" if form.condition.present?
+          trigger_sql += "EXECUTE FUNCTION #{form.function_name}();"
+
+          # Build the down method SQL
+          down_sql = "DROP TRIGGER IF EXISTS #{form.trigger_name} ON #{form.table_name};\n"
+          down_sql += "DROP FUNCTION IF EXISTS #{form.function_name}();"
+
+          <<~RUBY
+            # frozen_string_literal: true
+
+            # Generated by pg_sql_triggers on #{Time.current.strftime('%Y-%m-%d %H:%M:%S')}
+            class #{class_name} < PgSqlTriggers::Migration
+              def up
+                # Create the function
+                execute <<-SQL
+                  #{function_body_sql}
+                SQL
+
+                # Create the trigger
+                execute <<-SQL
+                  #{trigger_sql}
+                SQL
+              end
+
+              def down
+                execute <<-SQL
+                  #{down_sql}
+                SQL
+              end
+            end
+          RUBY
+        end
+
+        def generate_function_stub(form)
+          return nil unless form.generate_function_stub
+
+          # Generate PL/pgSQL function template
+          events_display = form.events.compact_blank.join(", ").upcase
+
+          <<~SQL
+            -- PL/pgSQL function for trigger: #{form.trigger_name}
+            -- Table: #{form.table_name}
+            -- Events: #{events_display}
+            -- Generated by pg_sql_triggers on #{Time.current.strftime('%Y-%m-%d %H:%M:%S')}
+            --
+            -- TODO: Implement your trigger logic below
+
+            CREATE OR REPLACE FUNCTION #{form.function_name}()
+            RETURNS TRIGGER AS $$
+            BEGIN
+              -- Access OLD record: OLD.column_name (for UPDATE, DELETE)
+              -- Access NEW record: NEW.column_name (for INSERT, UPDATE)
+
+              -- Example: Validate a field
+              -- IF NEW.some_field > threshold THEN
+              --   RAISE EXCEPTION 'Validation failed: %', NEW.some_field;
+              -- END IF;
+
+              -- TODO: Add your validation/business logic here
+              RAISE NOTICE 'Trigger function % called for %', TG_NAME, TG_OP;
+
+              -- For INSERT/UPDATE triggers, return NEW
+              -- For DELETE triggers, return OLD
+              -- For TRUNCATE triggers, return NULL
+              IF TG_OP = 'DELETE' THEN
+                RETURN OLD;
+              ELSIF TG_OP = 'TRUNCATE' THEN
+                RETURN NULL;
+              ELSE
+                RETURN NEW;
+              END IF;
+            END;
+            $$ LANGUAGE plpgsql;
+          SQL
+        end
+
+        def file_paths(form)
+          # NOTE: These paths are relative to the host Rails app, not the gem
+          # Generate both migration file and DSL file
+          migration_version = next_migration_number
+          {
+            migration: "db/triggers/#{migration_version}_#{form.trigger_name}.rb",
+            dsl: "app/triggers/#{form.trigger_name}.rb"
+          }
+        end
+
+        def create_trigger(form, _actor: nil)
+          paths = file_paths(form)
+
+          # Determine if we're in a Rails app context or standalone gem
+          base_path = defined?(Rails) && Rails.respond_to?(:root) ? Rails.root : Pathname.new(Dir.pwd)
+
+          full_migration_path = base_path.join(paths[:migration])
+          full_dsl_path = base_path.join(paths[:dsl])
+
+          # Create directories
+          FileUtils.mkdir_p(full_migration_path.dirname)
+          FileUtils.mkdir_p(full_dsl_path.dirname)
+
+          # Generate content
+          migration_content = generate_migration(form)
+          dsl_content = generate_dsl(form)
+          # Use function_body (required field)
+          function_content = form.function_body
+
+          # Write both files
+          File.write(full_migration_path, migration_content)
+          File.write(full_dsl_path, dsl_content)
+
+          # Register in TriggerRegistry
+          definition = {
+            name: form.trigger_name,
+            table_name: form.table_name,
+            events: form.events.compact_blank,
+            function_name: form.function_name,
+            version: form.version,
+            enabled: form.enabled,
+            environments: form.environments.compact_blank,
+            condition: form.condition
+          }
+
+          attributes = {
+            trigger_name: form.trigger_name,
+            table_name: form.table_name,
+            version: form.version,
+            enabled: form.enabled,
+            source: "dsl",
+            environment: form.environments.compact_blank.join(",").presence,
+            definition: definition.to_json,
+            function_body: function_content,
+            checksum: calculate_checksum(definition)
+          }
+
+          # Only include condition if the column exists and value is present
+          attributes[:condition] = form.condition.presence if TriggerRegistry.column_names.include?("condition")
+
+          registry = TriggerRegistry.create!(attributes)
+
+          {
+            success: true,
+            registry_id: registry.id,
+            migration_path: paths[:migration],
+            dsl_path: paths[:dsl],
+            metadata: {
+              trigger_name: form.trigger_name,
+              table_name: form.table_name,
+              events: form.events.compact_blank,
+              files_created: [paths[:migration], paths[:dsl]]
+            }
+          }
+        rescue StandardError => e
+          Rails.logger.error("Trigger generation failed: #{e.message}") if defined?(Rails)
+          Rails.logger.error(e.backtrace.join("\n")) if defined?(Rails)
+
+          {
+            success: false,
+            error: e.message
+          }
+        end
+
+        private
+
+        def next_migration_number
+          # Determine if we're in a Rails app context or standalone gem
+          base_path = defined?(Rails) && Rails.respond_to?(:root) ? Rails.root : Pathname.new(Dir.pwd)
+          triggers_path = base_path.join("db", "triggers")
+
+          # Get the highest migration number from existing migrations
+          existing = if Dir.exist?(triggers_path)
+                       Dir.glob(triggers_path.join("*.rb"))
+                          .map { |f| File.basename(f, ".rb").split("_").first.to_i }
+                          .reject(&:zero?)
+                          .max || 0
+                     else
+                       0
+                     end
+
+          # Generate next timestamp-based version
+          # Format: YYYYMMDDHHMMSS
+          now = Time.now.utc
+          base = now.strftime("%Y%m%d%H%M%S").to_i
+
+          # If we have existing migrations, ensure we're incrementing
+          base = existing + 1 if existing.positive? && base <= existing
+
+          base
+        end
+
+        def calculate_checksum(definition)
+          Digest::SHA256.hexdigest(definition.to_json)
+        end
+      end
+    end
+  end
+end

data/lib/pg_sql_triggers/generator.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module PgSqlTriggers
+  module Generator
+    autoload :Service, "pg_sql_triggers/generator/service"
+    autoload :Form, "pg_sql_triggers/generator/form"
+  end
+end

data/lib/pg_sql_triggers/migration.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module PgSqlTriggers
+  class Migration < ActiveRecord::Migration[6.0]
+    # Base class for trigger migrations
+    # Similar to ActiveRecord::Migration but for trigger-specific migrations
+
+    # rubocop:disable Rails/Delegate
+    # delegate doesn't work here due to argument forwarding issues in this context
+    def execute(sql)
+      connection.execute(sql)
+    end
+    # rubocop:enable Rails/Delegate
+  end
+end

data/lib/pg_sql_triggers/migrator.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require "ostruct"
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/module/delegation"
+
+module PgSqlTriggers
+  class Migrator
+    MIGRATIONS_TABLE_NAME = "trigger_migrations"
+
+    class << self
+      def migrations_path
+        Rails.root.join("db/triggers")
+      end
+
+      def migrations_table_exists?
+        ActiveRecord::Base.connection.table_exists?(MIGRATIONS_TABLE_NAME)
+      end
+
+      def ensure_migrations_table!
+        return if migrations_table_exists?
+
+        ActiveRecord::Base.connection.create_table MIGRATIONS_TABLE_NAME do |t|
+          t.string :version, null: false
+        end
+
+        ActiveRecord::Base.connection.add_index MIGRATIONS_TABLE_NAME, :version, unique: true
+      end
+
+      def current_version
+        ensure_migrations_table!
+        result = ActiveRecord::Base.connection.select_one(
+          "SELECT version FROM #{MIGRATIONS_TABLE_NAME} ORDER BY version DESC LIMIT 1"
+        )
+        result ? result["version"].to_i : 0
+      end
+
+      def migrations
+        return [] unless Dir.exist?(migrations_path)
+
+        files = Dir.glob(migrations_path.join("*.rb")).sort
+        files.map do |file|
+          basename = File.basename(file, ".rb")
+          # Handle Rails migration format: YYYYMMDDHHMMSS_name
+          # Extract version (timestamp) and name
+          if basename =~ /^(\d+)_(.+)$/
+            version = ::Regexp.last_match(1).to_i
+            name = ::Regexp.last_match(2)
+          else
+            # Fallback: treat first part as version
+            parts = basename.split("_", 2)
+            version = parts[0].to_i
+            name = parts[1] || basename
+          end
+
+          Struct.new(:version, :name, :filename, :path, keyword_init: true).new(
+            version: version,
+            name: name,
+            filename: File.basename(file),
+            path: file
+          )
+        end
+      end
+
+      def pending_migrations
+        current_ver = current_version
+        migrations.select { |m| m.version > current_ver }
+      end
+
+      def run(direction = :up, target_version = nil)
+        ensure_migrations_table!
+
+        case direction
+        when :up
+          run_up(target_version)
+        when :down
+          run_down(target_version)
+        end
+      end
+
+      def run_up(target_version = nil)
+        if target_version
+          # Apply a specific migration version
+          migration_to_apply = migrations.find { |m| m.version == target_version }
+          raise StandardError, "Migration version #{target_version} not found" if migration_to_apply.nil?
+
+          # Check if it's already applied
+          quoted_version = ActiveRecord::Base.connection.quote(target_version.to_s)
+          version_exists = ActiveRecord::Base.connection.select_value(
+            "SELECT 1 FROM #{MIGRATIONS_TABLE_NAME} WHERE version = #{quoted_version} LIMIT 1"
+          )
+
+          raise StandardError, "Migration version #{target_version} is already applied" if version_exists.present?
+
+          run_migration(migration_to_apply, :up)
+        else
+          # Apply all pending migrations
+          pending = pending_migrations
+          pending.each do |migration|
+            run_migration(migration, :up)
+          end
+        end
+      end
+
+      def run_down(target_version = nil)
+        current_ver = current_version
+        return if current_ver.zero?
+
+        if target_version
+          # Rollback to the specified version (rollback all migrations with version > target_version)
+          target_migration = migrations.find { |m| m.version == target_version }
+
+          raise StandardError, "Migration version #{target_version} not found or not applied" if target_migration.nil?
+
+          if current_ver <= target_version
+            raise StandardError, "Migration version #{target_version} not found or not applied"
+          end
+
+          migrations_to_rollback = migrations
+                                   .select { |m| m.version > target_version && m.version <= current_ver }
+                                   .sort_by(&:version)
+                                   .reverse
+
+        else
+          # Rollback the last migration by default
+          migrations_to_rollback = migrations
+                                   .select { |m| m.version == current_ver }
+                                   .sort_by(&:version)
+                                   .reverse
+
+        end
+        migrations_to_rollback.each do |migration|
+          run_migration(migration, :down)
+        end
+      end
+
+      def run_migration(migration, direction)
+        require migration.path
+
+        # Extract class name from migration name
+        # e.g., "posts_comment_count_validation" -> "PostsCommentCountValidation"
+        base_class_name = migration.name.camelize
+
+        # Try to find the class, trying multiple patterns:
+        # 1. Direct name (for backwards compatibility)
+        # 2. With "Add" prefix (for new migrations following Rails conventions)
+        # 3. With PgSqlTriggers namespace
+        migration_class = begin
+          base_class_name.constantize
+        rescue NameError
+          begin
+            # Try with "Add" prefix (Rails migration naming convention)
+            "Add#{base_class_name}".constantize
+          rescue NameError
+            begin
+              # Try with PgSqlTriggers namespace
+              "PgSqlTriggers::#{base_class_name}".constantize
+            rescue NameError
+              # Try with both Add prefix and PgSqlTriggers namespace
+              "PgSqlTriggers::Add#{base_class_name}".constantize
+            end
+          end
+        end
+
+        ActiveRecord::Base.transaction do
+          migration_instance = migration_class.new
+          migration_instance.public_send(direction)
+
+          connection = ActiveRecord::Base.connection
+          version_str = connection.quote(migration.version.to_s)
+
+          if direction == :up
+            connection.execute(
+              "INSERT INTO #{MIGRATIONS_TABLE_NAME} (version) VALUES (#{version_str})"
+            )
+          else
+            connection.execute(
+              "DELETE FROM #{MIGRATIONS_TABLE_NAME} WHERE version = #{version_str}"
+            )
+            # Clean up registry entries for triggers that no longer exist in database
+            cleanup_orphaned_registry_entries
+          end
+        end
+      rescue LoadError => e
+        raise StandardError, "Error loading trigger migration #{migration.filename}: #{e.message}"
+      rescue StandardError => e
+        raise StandardError,
+              "Error running trigger migration #{migration.filename}: #{e.message}\n#{e.backtrace.first(5).join("\n")}"
+      end
+
+      def status
+        ensure_migrations_table!
+        current_version
+
+        migrations.map do |migration|
+          # Check if this specific migration version exists in the migrations table
+          # This is more reliable than just comparing versions
+          quoted_version = ActiveRecord::Base.connection.quote(migration.version.to_s)
+          version_exists = ActiveRecord::Base.connection.select_value(
+            "SELECT 1 FROM #{MIGRATIONS_TABLE_NAME} WHERE version = #{quoted_version} LIMIT 1"
+          )
+          ran = version_exists.present?
+
+          {
+            version: migration.version,
+            name: migration.name,
+            status: ran ? "up" : "down",
+            filename: migration.filename
+          }
+        end
+      end
+
+      def version
+        current_version
+      end
+
+      # Clean up registry entries for triggers that no longer exist in the database
+      # This is called after rolling back migrations to keep the registry in sync
+      def cleanup_orphaned_registry_entries
+        return unless ActiveRecord::Base.connection.table_exists?("pg_sql_triggers_registry")
+
+        introspection = PgSqlTriggers::DatabaseIntrospection.new
+
+        # Get all triggers from registry
+        registry_triggers = PgSqlTriggers::TriggerRegistry.all
+
+        # Remove registry entries for triggers that don't exist in database
+        registry_triggers.each do |registry_trigger|
+          unless introspection.trigger_exists?(registry_trigger.trigger_name)
+            Rails.logger.info("Removing orphaned registry entry for trigger: #{registry_trigger.trigger_name}")
+            registry_trigger.destroy
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pg_sql_triggers/permissions/checker.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module PgSqlTriggers
+  module Permissions
+    class Checker
+      def self.can?(actor, action, environment: nil)
+        action_sym = action.to_sym
+
+        # If custom permission checker is configured, use it
+        if PgSqlTriggers.permission_checker
+          environment ||= PgSqlTriggers.default_environment.call if PgSqlTriggers.default_environment.respond_to?(:call)
+          return PgSqlTriggers.permission_checker.call(actor, action_sym, environment)
+        end
+
+        # Default behavior: allow all permissions
+        # This should be overridden in production via configuration
+        true
+      end
+
+      # rubocop:disable Naming/PredicateMethod
+      def self.check!(actor, action, environment: nil)
+        unless can?(actor, action, environment: environment)
+          action_sym = action.to_sym
+          required_level = Permissions::ACTIONS[action_sym] || "unknown"
+          raise PgSqlTriggers::PermissionError,
+                "Permission denied: #{action_sym} requires #{required_level} level access"
+        end
+        true
+      end
+      # rubocop:enable Naming/PredicateMethod
+    end
+  end
+end

data/lib/pg_sql_triggers/permissions.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module PgSqlTriggers
+  module Permissions
+    autoload :Checker, "pg_sql_triggers/permissions/checker"
+
+    # Permission levels
+    VIEWER = "viewer"
+    OPERATOR = "operator"
+    ADMIN = "admin"
+
+    # Actions
+    ACTIONS = {
+      view_triggers: VIEWER,
+      view_diffs: VIEWER,
+      enable_trigger: OPERATOR,
+      disable_trigger: OPERATOR,
+      apply_trigger: OPERATOR,
+      dry_run_sql: OPERATOR,
+      generate_trigger: OPERATOR,
+      test_trigger: OPERATOR,
+      drop_trigger: ADMIN,
+      execute_sql: ADMIN,
+      override_drift: ADMIN
+    }.freeze
+
+    def self.check!(actor, action, environment: nil)
+      Checker.check!(actor, action, environment: environment)
+    end
+
+    def self.can?(actor, action, environment: nil)
+      Checker.can?(actor, action, environment: environment)
+    end
+  end
+end

data/lib/pg_sql_triggers/registry/manager.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module PgSqlTriggers
+  module Registry
+    class Manager
+      class << self
+        def register(definition)
+          trigger_name = definition.name
+          existing = TriggerRegistry.find_by(trigger_name: trigger_name)
+
+          attributes = {
+            trigger_name: definition.name,
+            table_name: definition.table_name,
+            version: definition.version,
+            enabled: definition.enabled,
+            source: "dsl",
+            environment: definition.environments.join(","),
+            definition: definition.to_h.to_json
+          }
+
+          if existing
+            existing.update!(attributes)
+            existing
+          else
+            TriggerRegistry.create!(attributes.merge(checksum: "placeholder"))
+          end
+        end
+
+        def list
+          TriggerRegistry.all
+        end
+
+        delegate :enabled, to: :TriggerRegistry
+
+        delegate :disabled, to: :TriggerRegistry
+
+        delegate :for_table, to: :TriggerRegistry
+
+        def diff
+          # Compare DSL definitions with actual database state
+          # This will be implemented in the Drift::Detector
+          Drift.detect
+        end
+      end
+    end
+  end
+end

data/lib/pg_sql_triggers/registry/validator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module PgSqlTriggers
+  module Registry
+    class Validator
+      # rubocop:disable Naming/PredicateMethod
+      def self.validate!
+        # Validates all registry entries
+        # This is a placeholder implementation
+        true
+      end
+      # rubocop:enable Naming/PredicateMethod
+    end
+  end
+end

data/lib/pg_sql_triggers/registry.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module PgSqlTriggers
+  module Registry
+    autoload :Manager, "pg_sql_triggers/registry/manager"
+    autoload :Validator, "pg_sql_triggers/registry/validator"
+
+    def self.register(definition)
+      Manager.register(definition)
+    end
+
+    def self.list
+      Manager.list
+    end
+
+    def self.enabled
+      Manager.enabled
+    end
+
+    def self.disabled
+      Manager.disabled
+    end
+
+    def self.for_table(table_name)
+      Manager.for_table(table_name)
+    end
+
+    def self.diff
+      Manager.diff
+    end
+
+    def self.validate!
+      Validator.validate!
+    end
+  end
+end