pg_sql_triggers 1.3.0 → 1.4.0

data/app/controllers/pg_sql_triggers/generator_controller.rb

@@ -1,213 +0,0 @@
-# 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
-      # Restore form data from session if available (when user clicks "Back to Edit")
-      session_data = session[:generator_form_data]
-      if session_data
-        # Convert to hash and symbolize keys for Form initialization
-        form_data = session_data.is_a?(Hash) ? session_data.symbolize_keys : session_data.to_h.symbolize_keys
-        @form = PgSqlTriggers::Generator::Form.new(form_data)
-        session.delete(:generator_form_data)
-      else
-        @form = PgSqlTriggers::Generator::Form.new
-      end
-      @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 user clicked "Back to Edit", store form data in session and redirect
-      if params[:back_to_edit].present?
-        # Store form data as a hash (convert ActionController::Parameters to hash)
-        session[:generator_form_data] = generator_params.to_h
-        redirect_to new_generator_path
-        return
-      end
-
-      if @form.valid?
-        # Store form data in session so it can be restored if user clicks "Back to Edit"
-        # Convert ActionController::Parameters to hash
-        session[:generator_form_data] = generator_params.to_h
-
-        # 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
-      # Check kill switch before generating trigger
-      check_kill_switch(operation: :ui_trigger_generate, confirmation: params[:confirmation_text])
-
-      @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]
-          # Clear session data after successful creation
-          session.delete(:generator_form_data)
-          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
-    rescue PgSqlTriggers::KillSwitchError => e
-      flash[:error] = e.message
-      redirect_to root_path
-    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.require(:pg_sql_triggers_generator_form).permit(
-        :trigger_name, :table_name, :function_name, :version,
-        :enabled, :condition, :timing, :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
-      # Only include condition if the column exists
-      registry_attributes = {
-        trigger_name: form.trigger_name,
-        table_name: form.table_name,
-        function_body: form.function_body
-      }
-      # Only set condition if the column exists in the database
-      if PgSqlTriggers::TriggerRegistry.column_names.include?("condition")
-        registry_attributes[:condition] = form.condition
-      end
-
-      temp_registry = PgSqlTriggers::TriggerRegistry.new(registry_attributes)
-
-      # Build definition JSON for condition validation
-      definition = {
-        name: form.trigger_name,
-        table_name: form.table_name,
-        function_name: form.function_name,
-        events: form.events.compact_blank,
-        version: form.version,
-        enabled: form.enabled,
-        environments: form.environments.compact_blank,
-        condition: form.condition,
-        timing: form.timing || "before",
-        function_body: form.function_body
-      }
-      temp_registry.definition = definition.to_json
-
-      validator = PgSqlTriggers::Testing::SyntaxValidator.new(temp_registry)
-
-      # Validate function syntax
-      function_result = validator.validate_function_syntax
-      return function_result unless function_result[:valid]
-
-      # Validate condition if present
-      if form.condition.present?
-        condition_result = validator.validate_condition
-        unless condition_result[:valid]
-          return {
-            valid: false,
-            error: "WHEN condition validation failed: #{condition_result[:error]}"
-          }
-        end
-      end
-
-      function_result
-    rescue StandardError => e
-      { valid: false, error: "Validation error: #{e.message}" }
-    end
-  end
-end

data/app/controllers/pg_sql_triggers/sql_capsules_controller.rb

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-
-module PgSqlTriggers
-  class SqlCapsulesController < ApplicationController
-    before_action :check_admin_permission, only: [:execute]
-    before_action :check_operator_permission, only: %i[new create show]
-    before_action :load_capsule, only: %i[show execute]
-
-    def show
-      unless @capsule
-        redirect_to new_sql_capsule_path, alert: "Capsule not found"
-        return
-      end
-
-      @checksum = @capsule.checksum
-      @can_execute = can_execute_capsule?
-    end
-
-    def new
-      @capsule_name = params[:name] || ""
-      @environment = params[:environment] || current_environment
-      @purpose = params[:purpose] || ""
-      @sql = params[:sql] || ""
-    end
-
-    def create
-      # Strip whitespace from parameters
-      @capsule_name = params[:name].to_s.strip
-      @environment = params[:environment].to_s.strip
-      @purpose = params[:purpose].to_s.strip
-      @sql = params[:sql].to_s.strip
-
-      capsule = build_capsule_from_params
-
-      # Save the capsule to registry
-      result = save_capsule_to_registry(capsule)
-
-      if result[:success]
-        redirect_to sql_capsule_path(id: @capsule_name),
-                    notice: "SQL Capsule '#{capsule.name}' created successfully"
-      else
-        flash.now[:alert] = result[:message]
-        render :new
-      end
-    rescue ArgumentError => e
-      flash.now[:alert] = "Invalid capsule: #{e.message}"
-      render :new
-    end
-
-    def execute
-      unless @capsule
-        redirect_to new_sql_capsule_path, alert: "Capsule not found"
-        return
-      end
-
-      # Check kill switch with confirmation
-      check_kill_switch(
-        operation: :execute_sql_capsule,
-        confirmation: params[:confirmation]
-      )
-
-      # Execute the capsule
-      result = PgSqlTriggers::SQL::Executor.execute(
-        @capsule,
-        actor: current_actor,
-        confirmation: params[:confirmation],
-        dry_run: false
-      )
-
-      if result[:success]
-        flash[:notice] = result[:message]
-      else
-        flash[:alert] = result[:message]
-      end
-      redirect_to sql_capsule_path(id: params[:id])
-    rescue PgSqlTriggers::KillSwitchError => e
-      flash[:alert] = "Kill switch blocked execution: #{e.message}"
-      redirect_to sql_capsule_path(id: params[:id])
-    rescue PgSqlTriggers::PermissionError => e
-      flash[:alert] = "Permission denied: #{e.message}"
-      redirect_to sql_capsule_path(id: params[:id])
-    rescue StandardError => e
-      Rails.logger.error("SQL Capsule execution failed: #{e.message}\n#{e.backtrace.join("\n")}")
-      flash[:alert] = "Execution failed: #{e.message}"
-      redirect_to sql_capsule_path(id: params[:id])
-    end
-
-    private
-
-    def check_admin_permission
-      return if PgSqlTriggers::Permissions.can?(current_actor, :execute_sql)
-
-      redirect_to dashboard_path, alert: "Insufficient permissions. Admin role required."
-    end
-
-    def check_operator_permission
-      return if PgSqlTriggers::Permissions.can?(current_actor, :generate_trigger)
-
-      redirect_to dashboard_path, alert: "Insufficient permissions. Operator role required."
-    end
-
-    def build_capsule_from_params
-      PgSqlTriggers::SQL::Capsule.new(
-        name: params[:name].to_s.strip,
-        environment: params[:environment].to_s.strip,
-        purpose: params[:purpose].to_s.strip,
-        sql: params[:sql].to_s.strip
-      )
-    end
-
-    def save_capsule_to_registry(capsule)
-      # Check if capsule already exists
-      existing = PgSqlTriggers::TriggerRegistry.find_by(
-        trigger_name: capsule.registry_trigger_name,
-        source: "manual_sql"
-      )
-
-      if existing
-        return {
-          success: false,
-          message: "A capsule with this name already exists. Please choose a different name."
-        }
-      end
-
-      # Create new registry entry
-      registry_entry = PgSqlTriggers::TriggerRegistry.new(
-        trigger_name: capsule.registry_trigger_name,
-        table_name: "manual_sql_execution",
-        version: Time.current.to_i,
-        checksum: capsule.checksum,
-        source: "manual_sql",
-        function_body: capsule.sql,
-        condition: capsule.purpose,
-        environment: capsule.environment,
-        enabled: false # Not executed yet
-      )
-
-      if registry_entry.save
-        { success: true, message: "Capsule saved successfully" }
-      else
-        { success: false, message: "Failed to save capsule: #{registry_entry.errors.full_messages.join(', ')}" }
-      end
-    rescue StandardError => e
-      Rails.logger.error("Failed to save capsule to registry: #{e.message}")
-      { success: false, message: "Failed to save capsule: #{e.message}" }
-    end
-
-    def load_capsule
-      return if params[:id].blank?
-
-      @capsule = PgSqlTriggers::SQL::Executor.send(
-        :load_capsule_from_registry,
-        params[:id]
-      )
-    end
-
-    def can_execute_capsule?
-      PgSqlTriggers::Permissions.can?(current_actor, :execute_sql)
-    end
-  end
-end