pg_sql_triggers 1.4.0 → 1.5.0

data/app/views/pg_sql_triggers/triggers/show.html.erb

@@ -131,6 +131,39 @@
   </div>
 <% end %>
 
+<% rel = @dependency_related || { prerequisites: [], dependents: [] } %>
+<% if rel[:prerequisites].any? || rel[:dependents].any? %>
+  <div style="background: white; padding: 1.5rem; border-radius: 4px; box-shadow: 0 1px 3px rgba(0,0,0,0.1); margin-bottom: 2rem;">
+    <h3 style="margin-top: 0;">Trigger ordering (depends_on)</h3>
+    <p style="color: #6c757d; font-size: 0.875rem; margin-bottom: 1rem;">
+      PostgreSQL runs triggers of the same kind in alphabetical order by name. The DSL <code>depends_on</code> records intended order;
+      <code>rake trigger:validate_order</code> and <code>PgSqlTriggers::Registry.validate!</code> check that names and dependencies line up.
+    </p>
+
+    <% if rel[:prerequisites].any? %>
+      <div style="margin-bottom: 1rem;">
+        <strong>Runs after (depends_on):</strong>
+        <ul style="margin-top: 0.5rem;">
+          <% rel[:prerequisites].each do |dep_row| %>
+            <li><%= link_to dep_row.trigger_name, trigger_path(dep_row), style: "color: #007bff;" %></li>
+          <% end %>
+        </ul>
+      </div>
+    <% end %>
+
+    <% if rel[:dependents].any? %>
+      <div>
+        <strong>Runs before (other triggers depend on this one):</strong>
+        <ul style="margin-top: 0.5rem;">
+          <% rel[:dependents].each do |dep_row| %>
+            <li><%= link_to dep_row.trigger_name, trigger_path(dep_row), style: "color: #007bff;" %></li>
+          <% end %>
+        </ul>
+      </div>
+    <% end %>
+  </div>
+<% end %>
+
 <!-- SQL Diff (if drift detected) -->
 <% if @drift_info[:has_drift] && @drift_info[:expected_sql].present? %>
   <div style="background: white; padding: 1.5rem; border-radius: 4px; box-shadow: 0 1px 3px rgba(0,0,0,0.1); margin-bottom: 2rem;">

data/db/migrate/20260412185841_add_constraint_deferral_to_pg_sql_triggers_registry.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class AddConstraintDeferralToPgSqlTriggersRegistry < ActiveRecord::Migration[6.1]
+  def change
+    add_column :pg_sql_triggers_registry, :constraint_trigger, :boolean, default: false, null: false
+    add_column :pg_sql_triggers_registry, :deferrable, :string
+    add_column :pg_sql_triggers_registry, :initially, :string
+  end
+end

data/docs/README.md

@@ -27,6 +27,9 @@ Welcome to the PgSqlTriggers documentation. This directory contains comprehensiv
 #### Install PgSqlTriggers
 Start with [Getting Started](getting-started.md)
 
+#### See bundled Rails schema migrations (`db/migrate`)
+[Getting Started — Gem schema migrations](getting-started.md#gem-schema-migrations) lists versioned migration files and run order.
+
 #### Learn the DSL syntax
 See [Usage Guide - Declaring Triggers](usage-guide.md#declaring-triggers)
 

data/docs/api-reference.md

@@ -607,6 +607,111 @@ timing :after   # Trigger fires after constraint checks
 **Parameters**:
 - `timing_value` (Symbol or String): Either `:before` or `:after`
 
+#### `on_update_of(*columns)`
+
+Column-level trigger. Sets the event to `update` and records the column list; the generated
+SQL emits `UPDATE OF "col1", "col2"` so the trigger only fires when those columns change.
+
+```ruby
+on_update_of :email, :status
+```
+
+**Parameters**:
+- `columns` (Symbols or Strings): One or more simple SQL identifiers
+
+Notes: calling `on(...)` clears the column list. The column list is part of the checksum.
+Names must match `[a-zA-Z_][a-zA-Z0-9_]*` — invalid identifiers are rejected by the validator.
+
+#### `constraint_trigger!` / `self.deferrable =` / `self.initially =`
+
+Declares a `CREATE CONSTRAINT TRIGGER` (instead of a regular `CREATE TRIGGER`) and optionally
+makes it deferrable.
+
+```ruby
+constraint_trigger!
+self.deferrable = :deferrable
+self.initially  = :deferred
+```
+
+**Valid values**:
+- `deferrable`: `:deferrable`, `:not_deferrable`, or `nil`
+- `initially`: `:deferred`, `:immediate`, or `nil` (only when `deferrable == :deferrable`)
+
+**Rules** enforced by `Registry::Validator`:
+- `deferrable` / `initially` require `constraint_trigger!`.
+- Constraint triggers must use `timing :after` and cannot use `:truncate` events.
+- `initially` requires `deferrable = :deferrable`.
+
+Drift detection reads deferral state from `pg_trigger.tgdeferrable` and `pg_trigger.tginitdeferred`,
+so out-of-band modifications are detected.
+
+#### `depends_on(*names)`
+
+Declares that this trigger must run after the named trigger(s) on the same table. PostgreSQL
+fires same-kind triggers in **alphabetical name order**, so `depends_on` does not change runtime
+ordering — it is a metadata hint that `Registry::Validator` uses to verify declared intent
+matches naming.
+
+```ruby
+depends_on "validate_user_email"
+depends_on "a_trigger", "b_trigger"
+```
+
+**Validation** (`rake trigger:validate_order` or `Registry.validate!`) checks:
+- Referenced triggers exist as DSL entries.
+- Prerequisite is on the same table with the same timing and `FOR EACH` granularity.
+- Events overlap with the dependent.
+- No circular dependencies.
+- The prerequisite's name sorts alphabetically before the dependent's.
+
+Related DSL triggers are surfaced on the trigger detail page via
+`Registry::Validator.related_triggers_for_show`.
+
+## Drift Alerting API
+
+### `PgSqlTriggers::Drift.check_and_notify`
+
+Convenience wrapper for `PgSqlTriggers::Alerting.check_and_notify`. Runs full drift detection,
+invokes `PgSqlTriggers.drift_notifier` when any result is in a drifted / dropped / unknown
+state, and emits an `ActiveSupport::Notifications` event `pg_sql_triggers.drift_check`.
+
+```ruby
+outcome = PgSqlTriggers::Drift.check_and_notify
+outcome[:results]    # All drift detection results
+outcome[:alertable]  # Subset that triggered notification
+outcome[:notified]   # true if the drift_notifier was called successfully
+```
+
+**Notifier signature**:
+```ruby
+PgSqlTriggers.drift_notifier = lambda do |drift_results, all_results:|
+  # drift_results: Array of alertable hashes (drifted / dropped / unknown)
+  # all_results: full result set for context
+end
+```
+
+Errors raised by the notifier are caught, logged to `Rails.logger`, and surfaced via the
+`:notifier_error` key on the `pg_sql_triggers.drift_check` notification payload.
+
+## Registry Validator API
+
+### `PgSqlTriggers::Registry::Validator.validate!`
+
+Loads all DSL triggers from the registry and raises `PgSqlTriggers::ValidationError` when any
+are misconfigured. Validates events, timing, `for_each`, column lists, deferral combinations,
+and `depends_on` references (existence, table/timing/granularity/event overlap, cycles, and
+alphabetical name order).
+
+### `PgSqlTriggers::Registry::Validator.trigger_order_validation_errors`
+
+Returns only the dependency/order error messages (without raising). Used by
+`rake trigger:validate_order`.
+
+### `PgSqlTriggers::Registry::Validator.related_triggers_for_show(record)`
+
+Returns `{ prerequisites: [...], dependents: [...] }` — arrays of `TriggerRegistry` records
+declared via `depends_on`. Used by the trigger detail view.
+
 ## TriggerRegistry Model
 
 The `TriggerRegistry` ActiveRecord model represents a trigger in the registry.
@@ -779,6 +884,34 @@ prod_triggers = PgSqlTriggers::TriggerRegistry.for_environment("production")
 
 **Returns**: Array of `TriggerRegistry` records
 
+## Rake Tasks
+
+| Task | Description |
+|------|-------------|
+| `trigger:migrate` | Apply pending trigger migrations (respects kill switch). |
+| `trigger:rollback [STEP=n]` | Rollback trigger migrations. |
+| `trigger:migrate:status` | Show status of all trigger migrations. |
+| `trigger:migrate:up VERSION=…` | Run a specific migration up. |
+| `trigger:migrate:down VERSION=…` | Run a specific migration down. |
+| `trigger:migrate:redo [STEP=n\|VERSION=…]` | Rollback and re-apply. |
+| `trigger:version` | Print the current trigger migration version. |
+| `trigger:abort_if_pending_migrations` | Raise if pending trigger migrations exist. |
+| `trigger:check_drift [FAIL_ON_DRIFT=1]` | Run drift detection; invoke `drift_notifier`; optionally exit non-zero on drift. |
+| `trigger:validate_order` | Validate `depends_on` references, cycles, compatibility, and PostgreSQL name order. |
+| `trigger:dump [FILE=…]` | Write managed triggers to `db/trigger_structure.sql` (or `FILE=…`). |
+| `trigger:load [FILE=…]` | Execute SQL from the snapshot file (respects kill switch). |
+| `db:migrate:with_triggers` | Run `db:migrate` then `trigger:migrate`. |
+| `db:rollback:with_triggers` | Rollback the most recent schema or trigger migration. |
+| `db:migrate:status:with_triggers` | Show both schema and trigger migration status. |
+| `db:version:with_triggers` | Show both schema and trigger current versions. |
+
+`ENV` flags that apply across tasks:
+
+- `CONFIRMATION_TEXT=…` — satisfy the kill switch in protected environments.
+- `SKIP_TRIGGER_MIGRATE_AFTER_SCHEMA_LOAD=1` — skip the `db:schema:load` → `trigger:migrate`
+  hook for a single invocation.
+- `TRIGGER_STRUCTURE_SQL=path` — alternative to `FILE=path` for `trigger:dump` / `trigger:load`.
+
 ## Usage Examples
 
 ### Complete Workflow

data/docs/audit-trail.md

@@ -385,7 +385,7 @@ PgSqlTriggers::AuditLog
 **Problem**: Operations are not being logged.
 
 **Solution**: 
-- Check that migrations are run (`rails db:migrate`)
+- Check that migrations are run (`rails db:migrate`). The audit log table is created by `20260103114508_create_pg_sql_triggers_audit_log.rb` (see [Gem schema migrations](getting-started.md#gem-schema-migrations)).
 - Verify the audit log table exists
 - Check Rails logs for audit logging errors
 

data/docs/configuration.md

@@ -10,6 +10,9 @@ Complete reference for configuring PgSqlTriggers in your Rails application.
 - [Kill Switch Configuration](#kill-switch-configuration)
 - [Permission System](#permission-system)
 - [Environment Detection](#environment-detection)
+- [Drift alerting](#drift-alerting)
+- [schema.rb and structure.sql integration](#schemarb-and-structuresql-integration)
+- [Migration and Safety Settings](#migration-and-safety-settings)
 - [Advanced Configuration](#advanced-configuration)
 - [Examples](#examples)
 
@@ -340,6 +343,175 @@ config.default_environment = -> {
 }
 ```
 
+## Drift alerting
+
+Drift checks can run from the web UI, Ruby API, or Rake. To push notifications when triggers are **drifted**, **dropped**, or **unknown** (external), set a notifier and schedule `trigger:check_drift` (for example via cron or your job runner).
+
+### `drift_notifier`
+
+- **Type**: `Proc`, `lambda`, or any object responding to `call`
+- **Default**: `nil` (no notifications)
+
+The callable receives:
+
+1. **First argument**: an Array of result hashes for problematic triggers only (same shape as `PgSqlTriggers::Drift::Detector.detect_all` elements).
+2. **Keyword argument** `all_results:`: the full result set from drift detection.
+
+```ruby
+PgSqlTriggers.configure do |config|
+  config.drift_notifier = lambda do |drift_results, all_results:|
+    next if drift_results.empty?
+
+    # Example: log, Slack, PagerDuty, email, etc.
+    Rails.logger.warn("[PgSqlTriggers] Drift: #{drift_results.map { |r| r[:state] }.tally.inspect}")
+  end
+end
+```
+
+### Rake task
+
+Run this from your **Rails application root** (tasks are loaded by the engine), or from the **gem repository** when developing the gem (the root `Rakefile` loads `rakelib/` so `trigger:*` tasks are available there too).
+
+```bash
+bundle exec rake trigger:check_drift
+```
+
+- Set `FAIL_ON_DRIFT=1` to exit with status **1** when any problematic trigger exists (useful in CI or monitoring scripts that treat non-zero as failure).
+- If problems exist and no notifier is configured, the task prints a reminder to set `drift_notifier`.
+
+### `ActiveSupport::Notifications`
+
+When Active Support is loaded, each run emits `pg_sql_triggers.drift_check` with payload keys including `:results`, `:alertable`, `:alertable_count`, `:total_count`, and `:notified`. Subscribe in an initializer to forward metrics to your APM or logging pipeline.
+
+### Example: Slack incoming webhook
+
+```ruby
+require "net/http"
+require "json"
+require "uri"
+
+PgSqlTriggers.configure do |config|
+  config.drift_notifier = lambda do |drift_results, all_results:|
+    uri = URI(ENV.fetch("SLACK_DRIFT_WEBHOOK_URL"))
+    text = "PgSqlTriggers drift: #{drift_results.size} issue(s)\n" +
+           drift_results.map { |r|
+             name = r[:registry_entry]&.trigger_name || r[:db_trigger]&.dig("trigger_name")
+             "- #{name}: #{r[:state]}"
+           }.join("\n")
+    Net::HTTP.post(uri, { text: text }.to_json, "Content-Type" => "application/json")
+  end
+end
+```
+
+### Example: PagerDuty Events API v2
+
+```ruby
+require "net/http"
+require "json"
+require "uri"
+
+PgSqlTriggers.configure do |config|
+  config.drift_notifier = lambda do |drift_results, all_results:|
+    uri = URI("https://events.pagerduty.com/v2/enqueue")
+    body = {
+      routing_key: ENV.fetch("PAGERDUTY_INTEGRATION_KEY"),
+      event_action: "trigger",
+      payload: {
+        summary: "PgSqlTriggers: #{drift_results.size} drift issue(s)",
+        severity: "error",
+        source: "pg_sql_triggers",
+        custom_details: { triggers: drift_results.map { |r| r.slice(:state, :details) } }
+      }
+    }
+    Net::HTTP.post(uri, body.to_json, "Content-Type" => "application/json")
+  end
+end
+```
+
+## schema.rb and structure.sql integration
+
+`rails db:schema:dump` cannot represent PostgreSQL triggers in `schema.rb`. PgSqlTriggers ships
+three opt-in hooks that keep triggers aligned with the Rails schema workflow.
+
+### `append_trigger_notes_to_schema_dump`
+
+When `true` (default), the engine prepends an extension onto `ActiveRecord::SchemaDumper` that
+appends a short comment block to `schema.rb` listing managed triggers and pointing at the
+relevant rake tasks. Disable it if you prefer `schema.rb` to be untouched.
+
+- **Type**: Boolean
+- **Default**: `true`
+
+```ruby
+config.append_trigger_notes_to_schema_dump = false
+```
+
+The annotation is suppressed automatically when `config.active_record.schema_format = :sql`.
+
+### `trigger_structure_sql_path`
+
+Path (or callable returning a path) for the SQL snapshot written by `rake trigger:dump` and
+read by `rake trigger:load`. Defaults to `Rails.root.join("db/trigger_structure.sql")`.
+
+- **Type**: `String`, `Pathname`, or callable returning one
+- **Default**: `nil` (uses `db/trigger_structure.sql`)
+
+```ruby
+config.trigger_structure_sql_path = Rails.root.join("db/triggers/snapshot.sql")
+
+# Or a lambda (useful for multi-tenant setups)
+config.trigger_structure_sql_path = -> {
+  Rails.root.join("db/triggers", "#{Apartment::Tenant.current}.sql")
+}
+```
+
+`FILE=path` or `TRIGGER_STRUCTURE_SQL=path` on the rake command line overrides this value per
+invocation.
+
+### `migrate_triggers_after_schema_load`
+
+When `true` (default), `db:schema:load` is enhanced to automatically invoke `trigger:migrate`
+after the schema has been loaded so pending trigger migrations apply to a freshly-loaded
+database.
+
+- **Type**: Boolean
+- **Default**: `true`
+
+```ruby
+config.migrate_triggers_after_schema_load = false
+```
+
+Set the environment variable `SKIP_TRIGGER_MIGRATE_AFTER_SCHEMA_LOAD=1` to skip the hook for a
+single invocation without changing configuration.
+
+## Migration and Safety Settings
+
+### `excluded_tables`
+
+Tables whose triggers are ignored by drift detection and registry listings. Useful when other
+systems (e.g. auditing extensions, logical replication) manage triggers on tables you do not
+want pg_sql_triggers to touch.
+
+- **Type**: Array of strings/symbols
+- **Default**: `[]`
+
+```ruby
+config.excluded_tables = %w[ar_internal_metadata schema_migrations]
+```
+
+### `allow_unsafe_migrations`
+
+When `false` (default), trigger migrations are vetted by `PgSqlTriggers::Migrator::SafetyValidator`
+before they execute. Setting this to `true` bypasses safety checks entirely — intended only for
+local development or one-off recovery operations.
+
+- **Type**: Boolean
+- **Default**: `false`
+
+```ruby
+config.allow_unsafe_migrations = Rails.env.development?
+```
+
 ## Advanced Configuration
 
 ### Complete Example

data/docs/getting-started.md

@@ -34,6 +34,20 @@ This will:
 2. Create migrations for the registry table
 3. Mount the engine at `/pg_sql_triggers`
 
+## Gem schema migrations
+
+The gem’s Rails schema migrations live under `db/migrate/` in this repository. Versions use the standard **`YYYYMMDDHHMMSS`** prefix (14 digits: date and clock time). Rails runs them in version order.
+
+Run order (oldest first):
+
+1. `20251222104327_create_pg_sql_triggers_tables.rb` — creates `pg_sql_triggers_registry`
+2. `20251229071916_add_timing_to_pg_sql_triggers_registry.rb` — adds `timing` on the registry
+3. `20260103114508_create_pg_sql_triggers_audit_log.rb` — creates `pg_sql_triggers_audit_log`
+4. `20260228162233_add_for_each_to_pg_sql_triggers_registry.rb` — adds `for_each` on the registry
+5. `20260412185841_add_constraint_deferral_to_pg_sql_triggers_registry.rb` — adds `constraint_trigger`, `deferrable`, `initially` on the registry
+
+If you upgrade the gem and rename migration files locally, update the corresponding rows in `schema_migrations` so the version strings match these filenames.
+
 ## Verify Installation
 
 After installation, you should have:

data/docs/permissions.md

@@ -18,7 +18,7 @@ The permission system provides three levels of access:
 
 - **Viewer**: Read-only access to view triggers and their status
 - **Operator**: Can enable/disable triggers, apply migrations, generate triggers
-- **Admin**: Full access including drop, re-execute, and SQL capsule execution
+- **Admin**: Full access including drop, re-execute, and the reserved `execute_sql` permission action for host-defined privileged SQL
 
 By default, all permissions are allowed (permissive mode). **You must configure permissions in production** to enforce access controls.
 
@@ -49,7 +49,7 @@ Admins have full access:
 - All Operator permissions
 - Drop triggers
 - Re-execute triggers
-- Execute SQL capsules
+- `execute_sql` (privileged SQL; for custom integrations — not used by built-in UI)
 - Override drift detection
 
 ## Actions and Required Roles
@@ -67,7 +67,7 @@ The following actions are mapped to permission levels:
 | `generate_trigger` | Operator | Generate triggers via UI |
 | `test_trigger` | Operator | Test trigger functions |
 | `drop_trigger` | Admin | Drop a trigger from database |
-| `execute_sql` | Admin | Execute SQL capsules |
+| `execute_sql` | Admin | Privileged SQL (`permission_checker` / custom tooling; not used by built-in UI) |
 | `override_drift` | Admin | Override drift detection warnings |
 
 ## Configuration
@@ -272,12 +272,9 @@ PgSqlTriggers::Registry.drop(
   confirmation: "EXECUTE TRIGGER_DROP"
 )
 
-# Execute SQL capsule (requires Admin)
-PgSqlTriggers::SQL::Executor.execute(
-  capsule,
-  actor: current_user,
-  confirmation: "EXECUTE SQL"
-)
+# Custom tooling: gate raw SQL with the Admin-level :execute_sql action (requires Admin)
+PgSqlTriggers::Permissions.check!(current_user, :execute_sql)
+# ... your application's SQL execution ...
 ```
 
 ### Permission Errors in Console

data/docs/usage-guide.md

@@ -91,6 +91,80 @@ timing :before  # Trigger fires before constraint checks (default)
 timing :after   # Trigger fires after constraint checks
 ```
 
+#### `on_update_of`
+Declares a **column-level** trigger that fires only when specific columns change
+(PostgreSQL `UPDATE OF col1, col2`). This is a common performance optimisation for audit
+triggers: they run only when the columns you care about are modified.
+
+```ruby
+on_update_of :email, :status   # Sets event to UPDATE and records columns
+```
+
+Notes:
+- `on_update_of` sets the event to `update` and stores the column list; calling `on(...)` again
+  clears the column list.
+- Column names must be simple SQL identifiers (`[a-zA-Z_][a-zA-Z0-9_]*`). The gem quotes them
+  in generated SQL, so pass them unquoted.
+- The column list is included in the checksum, so changing the list is detected as drift.
+
+#### `constraint_trigger!` / `deferrable` / `initially`
+Declares a **constraint trigger** (`CREATE CONSTRAINT TRIGGER`) with optional deferral. Constraint
+triggers must be `AFTER` triggers, cannot use `TRUNCATE`, and are the only triggers that can be
+deferred.
+
+```ruby
+PgSqlTriggers::DSL.pg_sql_trigger "orders_integrity_check" do
+  table :orders
+  on :insert, :update
+  function :check_orders_referential_integrity
+
+  constraint_trigger!         # Emits CREATE CONSTRAINT TRIGGER, forces timing :after
+  self.deferrable = :deferrable
+  self.initially  = :deferred # Evaluate at transaction commit
+end
+```
+
+Valid combinations:
+
+| `deferrable`        | `initially`                | SQL clause                          |
+|---------------------|----------------------------|-------------------------------------|
+| `:deferrable`       | `:deferred`                | `DEFERRABLE INITIALLY DEFERRED`     |
+| `:deferrable`       | `:immediate` (or `nil`)    | `DEFERRABLE INITIALLY IMMEDIATE`    |
+| `:not_deferrable`   | (must be `nil`)            | `NOT DEFERRABLE`                    |
+| `nil`               | `nil`                      | (no deferral clause)                |
+
+`Registry::Validator` rejects `deferrable`/`initially` unless `constraint_trigger!` is set,
+and rejects constraint triggers that use `:before` timing or `TRUNCATE` events. Drift detection
+reads deferral state from `pg_trigger.tgdeferrable` / `tginitdeferred` so changes made outside
+the gem are surfaced as drift.
+
+#### `depends_on`
+Declares an **ordering hint** relative to another trigger on the same table. PostgreSQL fires
+same-kind triggers in alphabetical order by name; `depends_on` captures the intended order so the
+registry validator can verify that naming matches dependency declarations.
+
+```ruby
+PgSqlTriggers::DSL.pg_sql_trigger "log_user_change" do
+  table :users
+  on :insert, :update
+  function :log_user_change
+  timing :after
+
+  depends_on "validate_user_email"   # Must exist on same table, same timing/FOR EACH, overlapping events
+end
+```
+
+Run `rake trigger:validate_order` (or `PgSqlTriggers::Registry.validate!`) to enforce:
+
+- Referenced prerequisite triggers exist and are on the same table.
+- Prerequisites share timing (`before`/`after`), `FOR EACH` granularity, and have at least one
+  overlapping event with the dependent.
+- There are no circular dependencies.
+- Names sort alphabetically in the required order (the prerequisite's name must sort before
+  the dependent's).
+
+The trigger detail page in the web UI displays prerequisites and dependents for DSL triggers.
+
 ### Complete Example
 
 ```ruby

data/lib/generators/pg_sql_triggers/templates/initializer.rb

@@ -66,4 +66,18 @@ PgSqlTriggers.configure do |config|
   # You can also override per-migration with ALLOW_UNSAFE_MIGRATIONS=true environment variable
   # Default: false (recommended for safety)
   config.allow_unsafe_migrations = false
+
+  # ========== Schema / structure.sql integration ==========
+  # Triggers are not included in db/schema.rb. After db:schema:load, the engine runs
+  # trigger:migrate by default. Set SKIP_TRIGGER_MIGRATE_AFTER_SCHEMA_LOAD=1 to skip.
+  # config.migrate_triggers_after_schema_load = true
+  #
+  # Optional: append comments to schema.rb pointing at db/trigger_structure.sql.
+  # config.append_trigger_notes_to_schema_dump = true
+  #
+  # Snapshot live trigger SQL: bin/rails trigger:dump (apply with trigger:load).
+  # config.trigger_structure_sql_path = Rails.root.join("db/trigger_structure.sql")
+  #
+  # For databases where triggers must appear in the main SQL dump, prefer:
+  #   config.active_record.schema_format = :sql
 end