pg_sql_triggers 1.2.0 → 1.4.0

data/lib/pg_sql_triggers/generator/service.rb

@@ -1,307 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require "digest"
-require "active_support/core_ext/string/inflections"
-
-module PgSqlTriggers
-  module Generator
-    # rubocop:disable Metrics/ClassLength
-    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}
-              timing :#{form.timing || 'before'}
-          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
-          timing_value = (form.timing || "before").upcase
-          trigger_sql = "CREATE TRIGGER #{form.trigger_name}\n"
-          trigger_sql += "#{timing_value} #{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}();"
-
-          # Indent SQL strings to match heredoc indentation (18 spaces)
-          indented_function_body = indent_sql(function_body_sql, 18)
-          indented_trigger_sql = indent_sql(trigger_sql, 18)
-          indented_down_sql = indent_sql(down_sql, 18)
-
-          <<~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
-                  #{indented_function_body}
-                SQL
-
-                # Create the trigger
-                execute <<-SQL
-                  #{indented_trigger_sql}
-                SQL
-              end
-
-              def down
-                execute <<-SQL
-                  #{indented_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) # rubocop:disable Lint/UnusedMethodArgument
-          paths = file_paths(form)
-          base_path = rails_base_path
-
-          create_trigger_files(form, paths, base_path)
-          registry = register_trigger(form)
-
-          build_success_response(registry, paths, form)
-        rescue StandardError => e
-          log_error(e)
-          build_error_response(e)
-        end
-
-        private
-
-        def indent_sql(sql_string, indent_level)
-          indent = " " * indent_level
-          sql_string.lines.map do |line|
-            stripped = line.chomp
-            stripped.empty? ? "" : indent + stripped
-          end.join("\n")
-        end
-
-        def rails_base_path
-          defined?(Rails) && Rails.respond_to?(:root) ? Rails.root : Pathname.new(Dir.pwd)
-        end
-
-        def create_trigger_files(form, paths, base_path)
-          full_migration_path = base_path.join(paths[:migration])
-          full_dsl_path = base_path.join(paths[:dsl])
-
-          FileUtils.mkdir_p(full_migration_path.dirname)
-          FileUtils.mkdir_p(full_dsl_path.dirname)
-
-          migration_content = generate_migration(form)
-          dsl_content = generate_dsl(form)
-
-          File.write(full_migration_path, migration_content)
-          File.write(full_dsl_path, dsl_content)
-        end
-
-        def register_trigger(form)
-          definition = build_trigger_definition(form)
-          attributes = build_registry_attributes(form, definition)
-          TriggerRegistry.create!(attributes)
-        end
-
-        def build_trigger_definition(form)
-          {
-            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,
-            timing: form.timing || "before",
-            function_body: form.function_body
-          }
-        end
-
-        def build_registry_attributes(form, definition)
-          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: form.function_body,
-            checksum: calculate_checksum(definition)
-          }
-
-          add_conditional_attributes(attributes, form)
-          attributes
-        end
-
-        def add_conditional_attributes(attributes, form)
-          column_names = TriggerRegistry.column_names
-
-          attributes[:condition] = form.condition.presence if column_names.include?("condition")
-          attributes[:timing] = (form.timing || "before") if column_names.include?("timing")
-        end
-
-        def build_success_response(registry, paths, form)
-          {
-            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]]
-            }
-          }
-        end
-
-        def log_error(error)
-          return unless defined?(Rails)
-
-          Rails.logger.error("Trigger generation failed: #{error.message}")
-          Rails.logger.error(error.backtrace.join("\n"))
-        end
-
-        def build_error_response(error)
-          {
-            success: false,
-            error: error.message
-          }
-        end
-
-        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)
-          # Use field-concatenation algorithm (consistent with TriggerRegistry#calculate_checksum)
-          Digest::SHA256.hexdigest([
-            definition[:name],
-            definition[:table_name],
-            definition[:version],
-            definition[:function_body] || "",
-            definition[:condition] || "",
-            definition[:timing] || "before"
-          ].join)
-        end
-      end
-    end
-    # rubocop:enable Metrics/ClassLength
-  end
-end

data/lib/pg_sql_triggers/generator.rb

@@ -1,8 +0,0 @@
-# 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/sql/capsule.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require "digest"
-
-module PgSqlTriggers
-  module SQL
-    # Capsule represents a named SQL capsule with environment declaration and purpose
-    # Used for emergency operations and manual SQL execution
-    #
-    # @example Creating a SQL capsule
-    #   capsule = PgSqlTriggers::SQL::Capsule.new(
-    #     name: "fix_user_permissions",
-    #     environment: "production",
-    #     purpose: "Emergency fix for user permission issue",
-    #     sql: "UPDATE users SET role = 'admin' WHERE email = 'admin@example.com';"
-    #   )
-    #
-    class Capsule
-      attr_reader :name, :environment, :purpose, :sql, :created_at
-
-      # @param name [String] The name of the SQL capsule
-      # @param environment [String] The environment this capsule is intended for
-      # @param purpose [String] Description of what this capsule does and why
-      # @param sql [String] The SQL to execute
-      # @param created_at [Time, nil] The timestamp when the capsule was created (defaults to now)
-      def initialize(name:, environment:, purpose:, sql:, created_at: nil)
-        @name = name
-        @environment = environment
-        @purpose = purpose
-        @sql = sql
-        @created_at = created_at || Time.current
-        validate!
-      end
-
-      # Calculates the checksum of the SQL content
-      # @return [String] The SHA256 checksum of the SQL
-      def checksum
-        @checksum ||= Digest::SHA256.hexdigest(sql.to_s)
-      end
-
-      # Converts the capsule to a hash suitable for storage
-      # @return [Hash] The capsule data
-      def to_h
-        {
-          name: name,
-          environment: environment,
-          purpose: purpose,
-          sql: sql,
-          checksum: checksum,
-          created_at: created_at
-        }
-      end
-
-      # Returns the registry trigger name for this capsule
-      # SQL capsules are stored in the registry with a special naming pattern
-      # @return [String] The trigger name for registry storage
-      def registry_trigger_name
-        "sql_capsule_#{name}"
-      end
-
-      private
-
-      def validate!
-        errors = []
-        errors << "Name cannot be blank" if name.nil? || name.to_s.strip.empty?
-        errors << "Environment cannot be blank" if environment.nil? || environment.to_s.strip.empty?
-        errors << "Purpose cannot be blank" if purpose.nil? || purpose.to_s.strip.empty?
-        errors << "SQL cannot be blank" if sql.nil? || sql.to_s.strip.empty?
-
-        # Validate name format (alphanumeric, underscores, hyphens only)
-        unless name.to_s.match?(/\A[a-z0-9_-]+\z/i)
-          errors << "Name must contain only letters, numbers, underscores, and hyphens"
-        end
-
-        raise ArgumentError, "Invalid capsule: #{errors.join(', ')}" if errors.any?
-      end
-    end
-  end
-end

data/lib/pg_sql_triggers/sql/executor.rb

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-
-module PgSqlTriggers
-  module SQL
-    # Executor handles the execution of SQL capsules with safety checks and logging
-    #
-    # @example Execute a SQL capsule
-    #   capsule = PgSqlTriggers::SQL::Capsule.new(name: "fix", ...)
-    #   result = PgSqlTriggers::SQL::Executor.execute(capsule, actor: current_actor, confirmation: "EXECUTE FIX")
-    #
-    class Executor
-      class << self
-        # Executes a SQL capsule with safety checks
-        #
-        # @param capsule [Capsule] The SQL capsule to execute
-        # @param actor [Hash] Information about who is executing the capsule
-        # @param confirmation [String, nil] The confirmation text for kill switch
-        # @param dry_run [Boolean] If true, only validate without executing
-        # @return [Hash] Result of the execution with :success, :message, and :data keys
-        def execute(capsule, actor:, confirmation: nil, dry_run: false)
-          validate_capsule!(capsule)
-
-          # Check permissions
-          check_permissions!(actor)
-
-          # Check kill switch
-          check_kill_switch!(capsule, actor, confirmation)
-
-          # Log the execution attempt
-          log_execution_attempt(capsule, actor, dry_run)
-
-          if dry_run
-            return {
-              success: true,
-              message: "Dry run successful. SQL would be executed.",
-              data: { checksum: capsule.checksum }
-            }
-          end
-
-          # Execute in transaction
-          result = execute_in_transaction(capsule, actor)
-
-          # Update registry after successful execution
-          update_registry(capsule) if result[:success]
-
-          # Log the result
-          log_execution_result(capsule, actor, result)
-
-          result
-        rescue StandardError => e
-          log_execution_error(capsule, actor, e)
-          {
-            success: false,
-            message: "Execution failed: #{e.message}",
-            error: e
-          }
-        end
-
-        # Executes a SQL capsule by name from the registry
-        #
-        # @param capsule_name [String] The name of the capsule to execute
-        # @param actor [Hash] Information about who is executing the capsule
-        # @param confirmation [String, nil] The confirmation text for kill switch
-        # @param dry_run [Boolean] If true, only validate without executing
-        # @return [Hash] Result of the execution
-        def execute_capsule(capsule_name, actor:, confirmation: nil, dry_run: false)
-          capsule = load_capsule_from_registry(capsule_name)
-
-          unless capsule
-            return {
-              success: false,
-              message: "Capsule '#{capsule_name}' not found in registry"
-            }
-          end
-
-          execute(capsule, actor: actor, confirmation: confirmation, dry_run: dry_run)
-        end
-
-        private
-
-        def validate_capsule!(capsule)
-          raise ArgumentError, "Capsule must be a PgSqlTriggers::SQL::Capsule" unless capsule.is_a?(Capsule)
-        end
-
-        def check_permissions!(actor)
-          PgSqlTriggers::Permissions.check!(actor, :execute_sql)
-        rescue PgSqlTriggers::PermissionError => e
-          raise PgSqlTriggers::PermissionError,
-                "SQL capsule execution requires Admin role: #{e.message}"
-        end
-
-        def check_kill_switch!(_capsule, actor, confirmation)
-          PgSqlTriggers::SQL::KillSwitch.check!(
-            operation: :execute_sql_capsule,
-            environment: Rails.env,
-            confirmation: confirmation,
-            actor: actor
-          )
-        end
-
-        def execute_in_transaction(capsule, _actor)
-          ActiveRecord::Base.transaction do
-            result = ActiveRecord::Base.connection.execute(capsule.sql)
-
-            {
-              success: true,
-              message: "SQL capsule '#{capsule.name}' executed successfully",
-              data: {
-                checksum: capsule.checksum,
-                rows_affected: result.cmd_tuples || 0
-              }
-            }
-          end
-        end
-
-        def update_registry(capsule)
-          # Check if capsule already exists in registry
-          registry_entry = PgSqlTriggers::TriggerRegistry.find_or_initialize_by(
-            trigger_name: capsule.registry_trigger_name
-          )
-
-          registry_entry.assign_attributes(
-            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: true,
-            last_executed_at: Time.current
-          )
-
-          registry_entry.save!
-        rescue StandardError => e
-          logger&.error "[SQL_CAPSULE] Failed to update registry: #{e.message}"
-          # Don't fail the execution if registry update fails
-        end
-
-        def load_capsule_from_registry(capsule_name)
-          trigger_name = "sql_capsule_#{capsule_name}"
-          registry_entry = PgSqlTriggers::TriggerRegistry.find_by(
-            trigger_name: trigger_name,
-            source: "manual_sql"
-          )
-
-          return nil unless registry_entry
-
-          Capsule.new(
-            name: capsule_name,
-            environment: registry_entry.environment || Rails.env.to_s,
-            purpose: registry_entry.condition || "No purpose specified",
-            sql: registry_entry.function_body,
-            created_at: registry_entry.created_at
-          )
-        end
-
-        # Logging methods
-
-        def log_execution_attempt(capsule, actor, dry_run)
-          mode = dry_run ? "DRY_RUN" : "EXECUTE"
-          logger&.info "[SQL_CAPSULE] #{mode} ATTEMPT: name=#{capsule.name} " \
-                       "environment=#{capsule.environment} actor=#{format_actor(actor)}"
-        end
-
-        def log_execution_result(capsule, actor, result)
-          status = result[:success] ? "SUCCESS" : "FAILED"
-          logger&.info "[SQL_CAPSULE] #{status}: name=#{capsule.name} " \
-                       "environment=#{capsule.environment} actor=#{format_actor(actor)} " \
-                       "checksum=#{capsule.checksum}"
-        end
-
-        def log_execution_error(capsule, actor, error)
-          # Handle case where capsule might not be valid
-          capsule_name = capsule.respond_to?(:name) ? capsule.name : "invalid_capsule"
-          environment = capsule.respond_to?(:environment) ? capsule.environment : "unknown"
-
-          logger&.error "[SQL_CAPSULE] ERROR: name=#{capsule_name} " \
-                        "environment=#{environment} actor=#{format_actor(actor)} " \
-                        "error=#{error.class.name} message=#{error.message}"
-        end
-
-        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
-
-        def logger
-          if PgSqlTriggers.respond_to?(:logger) && PgSqlTriggers.logger
-            PgSqlTriggers.logger
-          elsif defined?(Rails) && Rails.respond_to?(:logger)
-            Rails.logger
-          end
-        end
-      end
-    end
-  end
-end