pg_sql_triggers 1.0.0

data/app/assets/stylesheets/pg_sql_triggers/application.css

@@ -0,0 +1,179 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ *= require_self
+ */
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+  margin: 0;
+  padding: 0;
+  background: #f5f7fa;
+}
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+  background: white;
+  box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+}
+
+th, td {
+  padding: 0.75rem;
+  text-align: left;
+  border-bottom: 1px solid #e1e8ed;
+}
+
+th {
+  background: #f8f9fa;
+  font-weight: 600;
+  color: #495057;
+}
+
+.badge {
+  display: inline-block;
+  padding: 0.25rem 0.5rem;
+  border-radius: 3px;
+  font-size: 0.875rem;
+  font-weight: 500;
+}
+
+.badge-success {
+  background: #d4edda;
+  color: #155724;
+}
+
+.badge-danger {
+  background: #f8d7da;
+  color: #721c24;
+}
+
+.badge-warning {
+  background: #fff3cd;
+  color: #856404;
+}
+
+.badge-info {
+  background: #d1ecf1;
+  color: #0c5460;
+}
+
+.btn {
+  display: inline-block;
+  padding: 0.5rem 1rem;
+  border-radius: 4px;
+  text-decoration: none;
+  font-weight: 500;
+  cursor: pointer;
+  border: none;
+  transition: all 0.2s;
+}
+
+.btn-primary {
+  background: #007bff;
+  color: white;
+}
+
+.btn-primary:hover {
+  background: #0056b3;
+}
+
+.btn-danger {
+  background: #dc3545;
+  color: white;
+}
+
+.btn-danger:hover {
+  background: #c82333;
+}
+
+.btn-success {
+  background: #28a745;
+  color: white;
+}
+
+.btn-success:hover {
+  background: #218838;
+}
+
+/* Form styles */
+fieldset {
+  border: 1px solid #dee2e6;
+  padding: 1rem;
+  margin-bottom: 2rem;
+  border-radius: 4px;
+}
+
+legend {
+  font-weight: 600;
+  color: #495057;
+  padding: 0 0.5rem;
+  width: auto;
+}
+
+input[type="text"],
+input[type="number"],
+select,
+textarea {
+  width: 100%;
+  padding: 0.5rem;
+  border: 1px solid #ced4da;
+  border-radius: 4px;
+  font-family: inherit;
+}
+
+input[type="text"]:focus,
+input[type="number"]:focus,
+select:focus,
+textarea:focus {
+  outline: none;
+  border-color: #007bff;
+  box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.25);
+}
+
+/* Code blocks */
+pre {
+  background: #f8f9fa;
+  padding: 1rem;
+  border-radius: 4px;
+  overflow-x: auto;
+  border: 1px solid #dee2e6;
+}
+
+code {
+  font-family: 'Monaco', 'Menlo', 'Consolas', monospace;
+  font-size: 0.9rem;
+}
+
+/* Alert boxes */
+.alert {
+  padding: 1rem;
+  border-radius: 4px;
+  margin-bottom: 1rem;
+  border-left: 4px solid;
+}
+
+.alert-info {
+  background: #d1ecf1;
+  border-color: #0c5460;
+  color: #0c5460;
+}
+
+.alert-warning {
+  background: #fff3cd;
+  border-color: #ffc107;
+  color: #856404;
+}
+
+.alert-success {
+  background: #d4edda;
+  border-color: #28a745;
+  color: #155724;
+}
+
+.alert-danger {
+  background: #f8d7da;
+  border-color: #dc3545;
+  color: #721c24;
+}

data/app/controllers/pg_sql_triggers/application_controller.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module PgSqlTriggers
+  class ApplicationController < ActionController::Base
+    include PgSqlTriggers::Engine.routes.url_helpers
+
+    protect_from_forgery with: :exception
+    layout "pg_sql_triggers/application"
+
+    before_action :check_permissions?
+
+    private
+
+    def check_permissions?
+      # Override this method in host application to implement custom permission checks
+      true
+    end
+
+    def current_actor
+      # Override this in host application to provide actual user
+      {
+        type: current_user_type,
+        id: current_user_id
+      }
+    end
+
+    def current_user_type
+      "User"
+    end
+
+    def current_user_id
+      "unknown"
+    end
+  end
+end

data/app/controllers/pg_sql_triggers/dashboard_controller.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module PgSqlTriggers
+  class DashboardController < ApplicationController
+    def index
+      @triggers = PgSqlTriggers::TriggerRegistry.order(created_at: :desc)
+      @stats = {
+        total: @triggers.count,
+        enabled: @triggers.enabled.count,
+        disabled: @triggers.disabled.count,
+        drifted: 0 # Will be calculated by Drift::Detector
+      }
+
+      # Migration status with pagination
+      begin
+        all_migrations = PgSqlTriggers::Migrator.status
+        @pending_migrations = PgSqlTriggers::Migrator.pending_migrations
+        @current_migration_version = PgSqlTriggers::Migrator.current_version
+
+        # Pagination
+        @per_page = (params[:per_page] || 20).to_i
+        @per_page = [@per_page, 100].min # Cap at 100
+        @page = (params[:page] || 1).to_i
+        @total_migrations = all_migrations.count
+        @total_pages = @total_migrations.positive? ? (@total_migrations.to_f / @per_page).ceil : 1
+        @page = @page.clamp(1, @total_pages) # Ensure page is within valid range
+
+        offset = (@page - 1) * @per_page
+        @migration_status = all_migrations.slice(offset, @per_page) || []
+      rescue StandardError => e
+        Rails.logger.error("Failed to fetch migration status: #{e.message}")
+        @migration_status = []
+        @pending_migrations = []
+        @current_migration_version = 0
+        @total_migrations = 0
+        @total_pages = 1
+        @page = 1
+        @per_page = 20
+      end
+    end
+  end
+end

data/app/controllers/pg_sql_triggers/generator_controller.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module PgSqlTriggers
+  class GeneratorController < ApplicationController
+    # Permissions: Require OPERATOR level for generation
+    before_action :check_operator_permission
+
+    # GET /generator/new
+    # Display the multi-step form wizard
+    def new
+      @form = PgSqlTriggers::Generator::Form.new
+      @available_tables = fetch_available_tables
+    end
+
+    # POST /generator/preview
+    # Preview generated DSL and function stub (AJAX or regular POST)
+    def preview
+      @form = PgSqlTriggers::Generator::Form.new(generator_params)
+
+      if @form.valid?
+        # Validate SQL function body (required field)
+        @sql_validation = validate_function_sql(@form)
+
+        @dsl_content = PgSqlTriggers::Generator::Service.generate_dsl(@form)
+        # Use function_body (required)
+        @function_content = @form.function_body
+        @file_paths = PgSqlTriggers::Generator::Service.file_paths(@form)
+
+        render :preview
+      else
+        @available_tables = fetch_available_tables
+        render :new
+      end
+    end
+
+    # POST /generator/create
+    # Actually create the files and register in TriggerRegistry
+    def create
+      @form = PgSqlTriggers::Generator::Form.new(generator_params)
+
+      if @form.valid?
+        # Validate SQL function body (required field)
+        sql_validation = validate_function_sql(@form)
+        unless sql_validation[:valid]
+          flash.now[:alert] = "Cannot create trigger: SQL validation failed - #{sql_validation[:error]}"
+          @available_tables = fetch_available_tables
+          @dsl_content = PgSqlTriggers::Generator::Service.generate_dsl(@form)
+          @function_content = @form.function_body
+          @file_paths = PgSqlTriggers::Generator::Service.file_paths(@form)
+          @sql_validation = sql_validation
+          render :preview
+          return
+        end
+
+        result = PgSqlTriggers::Generator::Service.create_trigger(@form, actor: current_actor)
+
+        if result[:success]
+          files_msg = "Migration: #{result[:migration_path]}, DSL: #{result[:dsl_path]}"
+          redirect_to root_path,
+                      notice: "Trigger generated successfully. Files created: #{files_msg}"
+        else
+          flash[:alert] = "Generation failed: #{result[:error]}"
+          @available_tables = fetch_available_tables
+          render :new
+        end
+      else
+        @available_tables = fetch_available_tables
+        render :new
+      end
+    end
+
+    # POST /generator/validate_table (AJAX)
+    # Validate that table exists in database
+    def validate_table
+      # Extract table_name from JSON request body
+      # Rails should parse JSON automatically, but handle both cases
+      table_name = extract_table_name_from_request
+
+      if table_name.blank?
+        render json: { valid: false, error: "Table name is required" }, status: :bad_request
+        return
+      end
+
+      validator = PgSqlTriggers::DatabaseIntrospection.new
+      result = validator.validate_table(table_name)
+      render json: result
+    end
+
+    # GET /generator/tables (AJAX)
+    # Fetch list of tables for dropdown
+    def tables
+      tables = fetch_available_tables
+      render json: { tables: tables }
+    end
+
+    private
+
+    def generator_params
+      params.expect(
+        pg_sql_triggers_generator_form: [:trigger_name, :table_name, :function_name, :version,
+                                         :enabled, :condition, :generate_function_stub, :function_body,
+                                         { events: [], environments: [] }]
+      )
+    end
+
+    def check_operator_permission
+      return if PgSqlTriggers::Permissions.can?(current_actor, :apply_trigger)
+
+      redirect_to root_path, alert: "Insufficient permissions. Operator role required."
+    end
+
+    def fetch_available_tables
+      PgSqlTriggers::DatabaseIntrospection.new.list_tables
+    rescue StandardError => e
+      Rails.logger.error("Failed to fetch tables: #{e.message}")
+      []
+    end
+
+    def extract_table_name_from_request
+      # Rails automatically parses JSON request bodies when Content-Type is application/json
+      # The parameters are available directly in params
+      table_name = params[:table_name]
+
+      # If not found, try accessing as string key (some Rails versions use string keys for JSON)
+      table_name ||= params["table_name"] if params.key?("table_name")
+
+      table_name
+    end
+
+    def validate_function_sql(form)
+      return nil if form.function_body.blank?
+
+      # Create a temporary trigger registry object for validation
+      temp_registry = PgSqlTriggers::TriggerRegistry.new(
+        trigger_name: form.trigger_name,
+        function_body: form.function_body
+      )
+
+      validator = PgSqlTriggers::Testing::SyntaxValidator.new(temp_registry)
+      validator.validate_function_syntax
+    rescue StandardError => e
+      { valid: false, error: "Validation error: #{e.message}" }
+    end
+  end
+end

data/app/controllers/pg_sql_triggers/migrations_controller.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module PgSqlTriggers
+  # Controller for managing trigger migrations via web UI
+  # Provides actions to run migrations up, down, and redo
+  class MigrationsController < ApplicationController
+    def up
+      target_version = params[:version]&.to_i
+      PgSqlTriggers::Migrator.ensure_migrations_table!
+
+      if target_version
+        PgSqlTriggers::Migrator.run_up(target_version)
+        flash[:success] = "Migration #{target_version} applied successfully."
+      else
+        pending = PgSqlTriggers::Migrator.pending_migrations
+        if pending.any?
+          PgSqlTriggers::Migrator.run_up
+          count = pending.count
+          flash[:success] = "Applied #{count} pending migration(s) successfully."
+        else
+          flash[:info] = "No pending migrations to apply."
+        end
+      end
+      redirect_to root_path
+    rescue StandardError => e
+      Rails.logger.error("Migration up failed: #{e.message}\n#{e.backtrace.join("\n")}")
+      flash[:error] = "Failed to apply migration: #{e.message}"
+      redirect_to root_path
+    end
+
+    def down
+      target_version = params[:version]&.to_i
+      PgSqlTriggers::Migrator.ensure_migrations_table!
+
+      current_version = PgSqlTriggers::Migrator.current_version
+      if current_version.zero?
+        flash[:warning] = "No migrations to rollback."
+        redirect_to root_path
+        return
+      end
+
+      if target_version
+        PgSqlTriggers::Migrator.run_down(target_version)
+        flash[:success] = "Migration version #{target_version} rolled back successfully."
+      else
+        # Rollback one migration by default
+        PgSqlTriggers::Migrator.run_down
+        flash[:success] = "Rolled back last migration successfully."
+      end
+      redirect_to root_path
+    rescue StandardError => e
+      Rails.logger.error("Migration down failed: #{e.message}\n#{e.backtrace.join("\n")}")
+      flash[:error] = "Failed to rollback migration: #{e.message}"
+      redirect_to root_path
+    end
+
+    def redo
+      target_version = params[:version]&.to_i
+      PgSqlTriggers::Migrator.ensure_migrations_table!
+
+      if target_version
+        PgSqlTriggers::Migrator.run_down(target_version)
+        PgSqlTriggers::Migrator.run_up(target_version)
+        flash[:success] = "Migration #{target_version} redone successfully."
+      else
+        current_version = PgSqlTriggers::Migrator.current_version
+        if current_version.zero?
+          flash[:warning] = "No migrations to redo."
+          redirect_to root_path
+          return
+        end
+
+        PgSqlTriggers::Migrator.run_down
+        PgSqlTriggers::Migrator.run_up
+        flash[:success] = "Last migration redone successfully."
+      end
+      redirect_to root_path
+    rescue StandardError => e
+      Rails.logger.error("Migration redo failed: #{e.message}\n#{e.backtrace.join("\n")}")
+      flash[:error] = "Failed to redo migration: #{e.message}"
+      redirect_to root_path
+    end
+  end
+end

data/app/controllers/pg_sql_triggers/tables_controller.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module PgSqlTriggers
+  class TablesController < ApplicationController
+    def index
+      all_tables = PgSqlTriggers::DatabaseIntrospection.new.tables_with_triggers
+      # Only show tables that have at least one trigger
+      @tables_with_triggers = all_tables.select { |t| t[:trigger_count].positive? }
+      @total_tables = @tables_with_triggers.count
+      @tables_with_trigger_count = @tables_with_triggers.count
+    end
+
+    def show
+      @table_info = PgSqlTriggers::DatabaseIntrospection.new.table_triggers(params[:id])
+      @columns = PgSqlTriggers::DatabaseIntrospection.new.table_columns(params[:id])
+
+      respond_to do |format|
+        format.html
+        format.json do
+          render json: {
+            table_name: @table_info[:table_name],
+            registry_triggers: @table_info[:registry_triggers].map do |t|
+              {
+                id: t.id,
+                trigger_name: t.trigger_name,
+                function_name: if t.definition.present?
+                                 begin
+                                   JSON.parse(t.definition)
+                                 rescue StandardError
+                                   {}
+                                 end["function_name"]
+                               end,
+                enabled: t.enabled,
+                version: t.version,
+                source: t.source
+              }
+            end,
+            database_triggers: @table_info[:database_triggers]
+          }
+        end
+      end
+    end
+  end
+end

data/app/models/pg_sql_triggers/application_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module PgSqlTriggers
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/pg_sql_triggers/trigger_registry.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module PgSqlTriggers
+  class TriggerRegistry < PgSqlTriggers::ApplicationRecord
+    self.table_name = "pg_sql_triggers_registry"
+
+    # Validations
+    validates :trigger_name, presence: true, uniqueness: true
+    validates :table_name, presence: true
+    validates :version, presence: true, numericality: { only_integer: true, greater_than: 0 }
+    validates :checksum, presence: true
+    validates :source, presence: true, inclusion: { in: %w[dsl generated manual_sql] }
+
+    # Scopes
+    scope :enabled, -> { where(enabled: true) }
+    scope :disabled, -> { where(enabled: false) }
+    scope :for_table, ->(table_name) { where(table_name: table_name) }
+    scope :for_environment, ->(env) { where(environment: [env, nil]) }
+    scope :by_source, ->(source) { where(source: source) }
+
+    # Drift states
+    def drift_state
+      # This will be implemented by the Drift::Detector
+      PgSqlTriggers::Drift.detect(trigger_name)
+    end
+
+    def enable!
+      # Check if trigger exists in database before trying to enable it
+      trigger_exists = false
+      begin
+        introspection = PgSqlTriggers::DatabaseIntrospection.new
+        trigger_exists = introspection.trigger_exists?(trigger_name)
+      rescue StandardError => e
+        # If checking fails, assume trigger doesn't exist and continue
+        Rails.logger.warn("Could not check if trigger exists: #{e.message}") if defined?(Rails.logger)
+      end
+
+      if trigger_exists
+        begin
+          # Enable the trigger in PostgreSQL
+          sql = "ALTER TABLE #{quote_identifier(table_name)} ENABLE TRIGGER #{quote_identifier(trigger_name)};"
+          ActiveRecord::Base.connection.execute(sql)
+        rescue ActiveRecord::StatementInvalid => e
+          # If trigger doesn't exist or can't be enabled, continue to update registry
+          Rails.logger.warn("Could not enable trigger: #{e.message}") if defined?(Rails.logger)
+        end
+      end
+
+      # Update the registry record (always update, even if trigger doesn't exist)
+      update!(enabled: true)
+    end
+
+    def disable!
+      # Check if trigger exists in database before trying to disable it
+      trigger_exists = false
+      begin
+        introspection = PgSqlTriggers::DatabaseIntrospection.new
+        trigger_exists = introspection.trigger_exists?(trigger_name)
+      rescue StandardError => e
+        # If checking fails, assume trigger doesn't exist and continue
+        Rails.logger.warn("Could not check if trigger exists: #{e.message}") if defined?(Rails.logger)
+      end
+
+      if trigger_exists
+        begin
+          # Disable the trigger in PostgreSQL
+          sql = "ALTER TABLE #{quote_identifier(table_name)} DISABLE TRIGGER #{quote_identifier(trigger_name)};"
+          ActiveRecord::Base.connection.execute(sql)
+        rescue ActiveRecord::StatementInvalid => e
+          # If trigger doesn't exist or can't be disabled, continue to update registry
+          Rails.logger.warn("Could not disable trigger: #{e.message}") if defined?(Rails.logger)
+        end
+      end
+
+      # Update the registry record (always update, even if trigger doesn't exist)
+      update!(enabled: false)
+    end
+
+    private
+
+    def quote_identifier(identifier)
+      ActiveRecord::Base.connection.quote_table_name(identifier.to_s)
+    end
+
+    def calculate_checksum
+      Digest::SHA256.hexdigest([trigger_name, table_name, version, function_body, condition].join)
+    end
+
+    def verify!
+      update!(last_verified_at: Time.current)
+    end
+  end
+end

data/app/views/layouts/pg_sql_triggers/application.html.erb

@@ -0,0 +1,72 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>PgSqlTriggers - PostgreSQL Trigger Control Plane</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= stylesheet_link_tag "pg_sql_triggers/application", media: "all" %>
+  <%= javascript_include_tag "pg_sql_triggers/application" %>
+</head>
+
+<body>
+  <nav style="background: #2c3e50; padding: 1rem; color: white;">
+    <div style="max-width: 1200px; margin: 0 auto; display: flex; justify-content: space-between; align-items: center;">
+      <h1 style="margin: 0; font-size: 1.5rem;">
+        <%= link_to "PgSqlTriggers", root_path, style: "color: white; text-decoration: none;" %>
+      </h1>
+      <div>
+        <%= link_to "Dashboard", root_path, style: "color: white; margin-right: 1rem;" %>
+        <%= link_to "Tables", tables_path, style: "color: white; margin-right: 1rem;" %>
+        <%= link_to "Generator", new_generator_path, style: "color: white;" %>
+      </div>
+    </div>
+  </nav>
+
+  <main style="max-width: 1200px; margin: 2rem auto; padding: 0 1rem;">
+    <% if flash[:success] %>
+      <div style="background: #d4edda; color: #155724; padding: 1rem; margin-bottom: 1rem; border-radius: 4px; border-left: 4px solid #28a745;">
+        <%= flash[:success] %>
+      </div>
+    <% end %>
+
+    <% if flash[:error] %>
+      <div style="background: #f8d7da; color: #721c24; padding: 1rem; margin-bottom: 1rem; border-radius: 4px; border-left: 4px solid #dc3545;">
+        <%= flash[:error] %>
+      </div>
+    <% end %>
+
+    <% if flash[:warning] %>
+      <div style="background: #fff3cd; color: #856404; padding: 1rem; margin-bottom: 1rem; border-radius: 4px; border-left: 4px solid #ffc107;">
+        <%= flash[:warning] %>
+      </div>
+    <% end %>
+
+    <% if flash[:info] %>
+      <div style="background: #d1ecf1; color: #0c5460; padding: 1rem; margin-bottom: 1rem; border-radius: 4px; border-left: 4px solid #17a2b8;">
+        <%= flash[:info] %>
+      </div>
+    <% end %>
+
+    <% if flash[:notice] %>
+      <div style="background: #d4edda; color: #155724; padding: 1rem; margin-bottom: 1rem; border-radius: 4px; border-left: 4px solid #28a745;">
+        <%= flash[:notice] %>
+      </div>
+    <% end %>
+
+    <% if flash[:alert] %>
+      <div style="background: #f8d7da; color: #721c24; padding: 1rem; margin-bottom: 1rem; border-radius: 4px; border-left: 4px solid #dc3545;">
+        <%= flash[:alert] %>
+      </div>
+    <% end %>
+
+    <%= yield %>
+  </main>
+
+  <footer style="background: #ecf0f1; padding: 2rem; margin-top: 4rem; text-align: center;">
+    <p style="margin: 0; color: #7f8c8d;">
+      PgSqlTriggers - A PostgreSQL Trigger Control Plane for Rails
+    </p>
+  </footer>
+</body>
+</html>