refactor(engine): replace long argument lists with params structs

Convert trigger firing (before/after/instead/common/batch/dml-hook) and
event-plane alert evaluation to take dedicated params structs instead
of long positional argument lists, updating all call sites accordingly.

Author: farhan-syah

nodedb/src/control/server/pgwire/handler/routing/execute.rs

@@ -399,12 +399,14 @@ impl NodeDbPgHandler {
             // --- AFTER triggers ---
             if let Some(ref info) = dml_info {
                 crate::control::trigger::dml_hook_fire::fire_post_dispatch_triggers(
-                    &self.state,
-                    identity,
-                    tenant_id,
-                    info,
-                    &old_row,
-                    0,
+                    crate::control::trigger::dml_hook_fire::DispatchTriggerParams {
+                        state: &self.state,
+                        identity,
+                        tenant_id,
+                        info,
+                        old_row: &old_row,
+                        cascade_depth: 0,
+                    },
                 )
                 .await
                 .map_err(|e| {

nodedb/src/control/server/pgwire/handler/routing/execute_dml_hooks.rs

@@ -165,12 +165,14 @@ impl NodeDbPgHandler {
         if let Some(ref info) = dml_info {
             use crate::control::trigger::dml_hook_fire::PreDispatchResult;
             match crate::control::trigger::dml_hook_fire::fire_pre_dispatch_triggers(
-                &self.state,
-                identity,
-                tenant_id,
-                info,
-                &old_row,
-                0,
+                crate::control::trigger::dml_hook_fire::DispatchTriggerParams {
+                    state: &self.state,
+                    identity,
+                    tenant_id,
+                    info,
+                    old_row: &old_row,
+                    cascade_depth: 0,
+                },
             )
             .await
             .map_err(|e| {

nodedb/src/control/server/shared/ddl/neutral/collection/dml/triggers.rs

@@ -51,14 +51,16 @@ pub(super) async fn fire_sync_after_update_triggers(
 ) -> Option<Result<Vec<DdlResult>, DdlError>> {
     use crate::control::security::catalog::trigger_types::TriggerExecutionMode;
     if let Err(e) = crate::control::trigger::fire_after::fire_after_update(
-        state,
-        identity,
-        tenant_id,
-        coll_name,
-        old_fields,
-        new_fields,
-        0,
-        Some(TriggerExecutionMode::Sync),
+        crate::control::trigger::fire_after::FireAfterUpdateParams {
+            state,
+            identity,
+            tenant_id,
+            collection: coll_name,
+            old_fields,
+            new_fields,
+            cascade_depth: 0,
+            mode_filter: Some(TriggerExecutionMode::Sync),
+        },
     )
     .await
     {

nodedb/src/control/trigger/batch/before.rs

@@ -32,6 +32,24 @@ pub struct BeforeBatchResult {
     pub errors: ErrorAccumulator,
 }
 
+/// Parameters for [`execute_before_batch`].
+pub struct BeforeBatchParams<'a> {
+    /// Shared server state (trigger registry, block cache).
+    pub state: &'a SharedState,
+    /// Caller identity (used unless a trigger is SECURITY DEFINER).
+    pub identity: &'a AuthenticatedIdentity,
+    /// Tenant scope for trigger lookup and execution.
+    pub tenant_id: TenantId,
+    /// Target collection name.
+    pub collection: &'a str,
+    /// DML event kind (INSERT/UPDATE/DELETE) the batch represents.
+    pub event: DmlEvent,
+    /// Rows to process; possibly mutated in place by BEFORE trigger ASSIGN statements.
+    pub rows: Vec<TriggerBatchRow>,
+    /// Current cascade depth, for infinite-loop protection.
+    pub cascade_depth: u32,
+}
+
 /// Execute BEFORE triggers over a batch of rows.
 ///
 /// For each BEFORE trigger on the collection:
@@ -41,16 +59,19 @@ pub struct BeforeBatchResult {
 /// 4. Capture per-row errors from RAISE EXCEPTION
 ///
 /// Returns the mutated batch + error accumulator.
-#[allow(clippy::too_many_arguments)]
 pub async fn execute_before_batch(
-    state: &SharedState,
-    identity: &AuthenticatedIdentity,
-    tenant_id: TenantId,
-    collection: &str,
-    event: DmlEvent,
-    mut rows: Vec<TriggerBatchRow>,
-    cascade_depth: u32,
+    params: BeforeBatchParams<'_>,
 ) -> crate::Result<BeforeBatchResult> {
+    let BeforeBatchParams {
+        state,
+        identity,
+        tenant_id,
+        collection,
+        event,
+        mut rows,
+        cascade_depth,
+    } = params;
+
     let triggers = state
         .trigger_registry
         .get_matching(tenant_id.as_u64(), collection, event);

nodedb/src/control/trigger/dml_hook_fire.rs

@@ -27,6 +27,22 @@ pub enum PreDispatchResult {
     },
 }
 
+/// Parameters shared by [`fire_pre_dispatch_triggers`] and [`fire_post_dispatch_triggers`].
+pub struct DispatchTriggerParams<'a> {
+    /// Shared server state (trigger registry, block cache).
+    pub state: &'a SharedState,
+    /// Caller identity (used unless a trigger is SECURITY DEFINER).
+    pub identity: &'a AuthenticatedIdentity,
+    /// Tenant scope for trigger lookup and execution.
+    pub tenant_id: TenantId,
+    /// The DML write being dispatched.
+    pub info: &'a DmlWriteInfo,
+    /// The row's prior state, for UPDATE/DELETE (`None` for INSERT).
+    pub old_row: &'a Option<HashMap<String, nodedb_types::Value>>,
+    /// Current cascade depth, for infinite-loop protection.
+    pub cascade_depth: u32,
+}
+
 /// Fire BEFORE + INSTEAD OF triggers for a point write.
 ///
 /// Returns `PreDispatchResult::Proceed` if the caller should dispatch normally.
@@ -37,15 +53,18 @@ pub enum PreDispatchResult {
 ///
 /// On BEFORE trigger error (RAISE EXCEPTION), the error propagates and
 /// the caller should abort the write.
-#[allow(clippy::too_many_arguments)]
 pub async fn fire_pre_dispatch_triggers(
-    state: &SharedState,
-    identity: &AuthenticatedIdentity,
-    tenant_id: TenantId,
-    info: &DmlWriteInfo,
-    old_row: &Option<HashMap<String, nodedb_types::Value>>,
-    cascade_depth: u32,
+    params: DispatchTriggerParams<'_>,
 ) -> crate::Result<PreDispatchResult> {
+    let DispatchTriggerParams {
+        state,
+        identity,
+        tenant_id,
+        info,
+        old_row,
+        cascade_depth,
+    } = params;
+
     // Check INSTEAD OF first — if it handles the write, skip everything else.
     match info.event {
         DmlEvent::Insert => {
@@ -70,13 +89,15 @@ pub async fn fire_pre_dispatch_triggers(
             let old_fields = old_row.as_ref().unwrap_or(&empty);
             let new_fields = info.new_fields.as_ref().unwrap_or(&empty);
             match super::fire_instead::fire_instead_of_update(
-                state,
-                identity,
-                tenant_id,
-                &info.collection,
-                old_fields,
-                new_fields,
-                cascade_depth,
+                super::fire_instead::InsteadOfUpdateParams {
+                    state,
+                    identity,
+                    tenant_id,
+                    collection: &info.collection,
+                    old_fields,
+                    new_fields,
+                    cascade_depth,
+                },
             )
             .await?
             {
@@ -168,15 +189,16 @@ pub async fn fire_pre_dispatch_triggers(
 ///
 /// Called after the Data Plane has committed the write. Only fires triggers
 /// with `execution_mode = Sync`. ASYNC triggers are handled by the Event Plane.
-#[allow(clippy::too_many_arguments)]
-pub async fn fire_post_dispatch_triggers(
-    state: &SharedState,
-    identity: &AuthenticatedIdentity,
-    tenant_id: TenantId,
-    info: &DmlWriteInfo,
-    old_row: &Option<HashMap<String, nodedb_types::Value>>,
-    cascade_depth: u32,
-) -> crate::Result<()> {
+pub async fn fire_post_dispatch_triggers(params: DispatchTriggerParams<'_>) -> crate::Result<()> {
+    let DispatchTriggerParams {
+        state,
+        identity,
+        tenant_id,
+        info,
+        old_row,
+        cascade_depth,
+    } = params;
+
     let empty = HashMap::new();
 
     // Fire SYNC AFTER ROW triggers.
@@ -198,16 +220,16 @@ pub async fn fire_post_dispatch_triggers(
         DmlEvent::Update => {
             let old_fields = old_row.as_ref().unwrap_or(&empty);
             let new_fields = info.new_fields.as_ref().unwrap_or(&empty);
-            fire_after::fire_after_update(
+            fire_after::fire_after_update(fire_after::FireAfterUpdateParams {
                 state,
                 identity,
                 tenant_id,
-                &info.collection,
+                collection: &info.collection,
                 old_fields,
                 new_fields,
                 cascade_depth,
-                Some(TriggerExecutionMode::Sync),
-            )
+                mode_filter: Some(TriggerExecutionMode::Sync),
+            })
             .await?;
         }
         DmlEvent::Delete => {

nodedb/src/control/trigger/fire.rs

@@ -5,8 +5,11 @@
 //! This file exists so that existing call sites (`control::trigger::fire::fire_after_insert`)
 //! continue to work. New code should import from the specific sub-modules.
 
-pub use super::fire_after::{fire_after_delete, fire_after_insert, fire_after_update, fire_sql};
+pub use super::fire_after::{
+    FireAfterUpdateParams, fire_after_delete, fire_after_insert, fire_after_update, fire_sql,
+};
 pub use super::fire_before::{fire_before_delete, fire_before_insert, fire_before_update};
 pub use super::fire_instead::{
-    InsteadOfResult, fire_instead_of_delete, fire_instead_of_insert, fire_instead_of_update,
+    InsteadOfResult, InsteadOfUpdateParams, fire_instead_of_delete, fire_instead_of_insert,
+    fire_instead_of_update,
 };

nodedb/src/control/trigger/fire_after.rs

@@ -73,21 +73,42 @@ pub async fn fire_after_insert(
     .await
 }
 
+/// Parameters for [`fire_after_update`].
+pub struct FireAfterUpdateParams<'a> {
+    /// Shared server state (trigger registry, block cache).
+    pub state: &'a SharedState,
+    /// Caller identity (used unless a trigger is SECURITY DEFINER).
+    pub identity: &'a AuthenticatedIdentity,
+    /// Tenant scope for trigger lookup and execution.
+    pub tenant_id: TenantId,
+    /// Target collection name.
+    pub collection: &'a str,
+    /// Row fields before the update (bound as `OLD.*`).
+    pub old_fields: &'a HashMap<String, nodedb_types::Value>,
+    /// Row fields after the update (bound as `NEW.*`).
+    pub new_fields: &'a HashMap<String, nodedb_types::Value>,
+    /// Current cascade depth, for infinite-loop protection.
+    pub cascade_depth: u32,
+    /// Restricts firing to a single execution mode; `None` fires all modes.
+    pub mode_filter: Option<TriggerExecutionMode>,
+}
+
 /// Fire AFTER ROW triggers for an UPDATE operation.
 ///
 /// `old_fields` is the row before the update, `new_fields` is after.
 /// Both are available as OLD.field and NEW.field in the trigger body.
-#[allow(clippy::too_many_arguments)]
-pub async fn fire_after_update(
-    state: &SharedState,
-    identity: &AuthenticatedIdentity,
-    tenant_id: TenantId,
-    collection: &str,
-    old_fields: &HashMap<String, nodedb_types::Value>,
-    new_fields: &HashMap<String, nodedb_types::Value>,
-    cascade_depth: u32,
-    mode_filter: Option<TriggerExecutionMode>,
-) -> crate::Result<()> {
+pub async fn fire_after_update(params: FireAfterUpdateParams<'_>) -> crate::Result<()> {
+    let FireAfterUpdateParams {
+        state,
+        identity,
+        tenant_id,
+        collection,
+        old_fields,
+        new_fields,
+        cascade_depth,
+        mode_filter,
+    } = params;
+
     let triggers =
         state
             .trigger_registry

nodedb/src/control/trigger/fire_before.rs

@@ -18,7 +18,10 @@ use crate::control::security::identity::AuthenticatedIdentity;
 use crate::control::state::SharedState;
 use crate::types::TenantId;
 
-use super::fire_common::{check_cascade_depth, fire_before_triggers_with_mutation, fire_triggers};
+use super::fire_common::{
+    BeforeTriggersMutationParams, check_cascade_depth, fire_before_triggers_with_mutation,
+    fire_triggers,
+};
 use super::registry::DmlEvent;
 
 /// Fire BEFORE ROW triggers for an INSERT operation.
@@ -54,16 +57,16 @@ pub async fn fire_before_insert(
 
     let bindings = RowBindings::before_insert(collection, new_fields.clone());
 
-    let result = fire_before_triggers_with_mutation(
+    let result = fire_before_triggers_with_mutation(BeforeTriggersMutationParams {
         state,
         identity,
         tenant_id,
         collection,
-        &before_triggers,
-        &bindings,
+        triggers: &before_triggers,
+        bindings: &bindings,
         cascade_depth,
-        Some(new_fields.clone()),
-    )
+        new_fields: Some(new_fields.clone()),
+    })
     .await?;
 
     // Return the (possibly mutated) NEW fields. If None somehow, return original.
@@ -103,16 +106,16 @@ pub async fn fire_before_update(
 
     let bindings = RowBindings::before_update(collection, old_fields.clone(), new_fields.clone());
 
-    let result = fire_before_triggers_with_mutation(
+    let result = fire_before_triggers_with_mutation(BeforeTriggersMutationParams {
         state,
         identity,
         tenant_id,
         collection,
-        &before_triggers,
-        &bindings,
+        triggers: &before_triggers,
+        bindings: &bindings,
         cascade_depth,
-        Some(new_fields.clone()),
-    )
+        new_fields: Some(new_fields.clone()),
+    })
     .await?;
 
     Ok(result.unwrap_or_else(|| new_fields.clone()))