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

Vector and spatial executor handlers took upwards of eight positional
arguments. Bundle them into per-handler params structs and update the
dispatch call sites to construct them, matching the pattern already
applied elsewhere in the engine.

Author: farhan-syah

nodedb/src/data/executor/dispatch/spatial.rs

@@ -58,20 +58,20 @@ impl CoreLoop {
                 projection,
                 rls_filters,
                 prefilter,
-            } => self.execute_spatial_scan(
+            } => self.execute_spatial_scan(super::super::handlers::spatial::SpatialScanParams {
                 task,
                 tid,
                 collection,
                 field,
                 predicate,
                 query_geometry,
-                *distance_meters,
+                distance_meters: *distance_meters,
                 attribute_filters,
-                *limit,
+                limit: *limit,
                 projection,
                 rls_filters,
-                prefilter.as_ref(),
-            ),
+                prefilter: prefilter.as_ref(),
+            }),
         }
     }
 }

nodedb/src/data/executor/dispatch/vector.rs

@@ -157,13 +157,15 @@ impl CoreLoop {
                 m0,
                 ef_construction,
             } => self.execute_vector_rebuild(
-                task,
-                tid,
-                collection,
-                field_name,
-                *m,
-                *m0,
-                *ef_construction,
+                super::super::handlers::vector_lifecycle::VectorRebuildParams {
+                    task,
+                    tid,
+                    collection,
+                    field_name,
+                    m: *m,
+                    m0: *m0,
+                    ef_construction: *ef_construction,
+                },
             ),
 
             VectorOp::SparseInsert {
@@ -196,14 +198,16 @@ impl CoreLoop {
                 count,
                 dim,
             } => self.execute_multi_vector_insert(
-                task,
-                tid,
-                collection,
-                field_name,
-                *document_surrogate,
-                vectors,
-                *count,
-                *dim,
+                super::super::handlers::vector_multi::MultiVectorInsertParams {
+                    task,
+                    tid,
+                    collection,
+                    field_name,
+                    document_surrogate: *document_surrogate,
+                    vectors_flat: vectors,
+                    count: *count,
+                    dim: *dim,
+                },
             ),
 
             VectorOp::MultiVectorDelete {
@@ -226,14 +230,16 @@ impl CoreLoop {
                 ef_search,
                 mode,
             } => self.execute_multi_vector_score_search(
-                task,
-                tid,
-                collection,
-                field_name,
-                query_vector,
-                *top_k,
-                *ef_search,
-                mode,
+                super::super::handlers::vector_multi::MultiVectorScoreSearchParams {
+                    task,
+                    tid,
+                    collection,
+                    field_name,
+                    query_vector,
+                    top_k: *top_k,
+                    ef_search: *ef_search,
+                    mode_str: mode,
+                },
             ),
 
             VectorOp::DirectUpsert {
@@ -246,16 +252,18 @@ impl CoreLoop {
                 storage_dtype,
                 payload_indexes,
             } => self.execute_vector_direct_upsert(
-                task,
-                tid,
-                collection,
-                field,
-                *surrogate,
-                vector,
-                payload,
-                *quantization,
-                *storage_dtype,
-                payload_indexes,
+                super::super::handlers::vector_upsert::VectorDirectUpsertParams {
+                    task,
+                    tid,
+                    collection,
+                    field,
+                    surrogate: *surrogate,
+                    vector,
+                    payload,
+                    quantization: *quantization,
+                    storage_dtype: *storage_dtype,
+                    payload_indexes,
+                },
             ),
 
             VectorOp::DeleteBySurrogate {

nodedb/src/data/executor/handlers/spatial.rs

@@ -18,29 +18,63 @@ use crate::data::executor::task::ExecutionTask;
 use nodedb_physical::physical_plan::SpatialPredicate;
 use nodedb_types::{Surrogate, SurrogateBitmap, Value};
 
+/// Parameters for [`CoreLoop::execute_spatial_scan`].
+pub(in crate::data::executor) struct SpatialScanParams<'a> {
+    pub task: &'a ExecutionTask,
+    pub tid: u64,
+    pub collection: &'a str,
+    pub field: &'a str,
+    pub predicate: &'a SpatialPredicate,
+    pub query_geometry: &'a nodedb_types::geometry::Geometry,
+    pub distance_meters: f64,
+    pub attribute_filters: &'a [u8],
+    pub limit: usize,
+    pub projection: &'a [String],
+    pub rls_filters: &'a [u8],
+    pub prefilter: Option<&'a SurrogateBitmap>,
+}
+
+/// Parameters for [`CoreLoop::spatial_full_scan`].
+struct SpatialFullScanParams<'a> {
+    task: &'a ExecutionTask,
+    tid: u64,
+    collection: &'a str,
+    field: &'a str,
+    predicate: &'a SpatialPredicate,
+    query_geom: &'a nodedb_types::geometry::Geometry,
+    distance_meters: f64,
+    limit: usize,
+    projection: &'a [String],
+    attr_filters: &'a [ScanFilter],
+    rls_filters: &'a [ScanFilter],
+    prefilter: Option<&'a SurrogateBitmap>,
+}
+
 impl CoreLoop {
     /// Execute a spatial scan using the R-tree index.
     ///
     /// 1. Parse query geometry from GeoJSON bytes
     /// 2. R-tree range search for bbox candidates
     /// 3. Exact predicate refinement (extract geometry, apply ST_*)
     /// 4. Return matching documents up to limit
-    #[allow(clippy::too_many_arguments)]
     pub(in crate::data::executor) fn execute_spatial_scan(
         &mut self,
-        task: &ExecutionTask,
-        tid: u64,
-        collection: &str,
-        field: &str,
-        predicate: &SpatialPredicate,
-        query_geometry: &nodedb_types::geometry::Geometry,
-        distance_meters: f64,
-        attribute_filters: &[u8],
-        limit: usize,
-        projection: &[String],
-        rls_filters: &[u8],
-        prefilter: Option<&SurrogateBitmap>,
+        params: SpatialScanParams<'_>,
     ) -> Response {
+        let SpatialScanParams {
+            task,
+            tid,
+            collection,
+            field,
+            predicate,
+            query_geometry,
+            distance_meters,
+            attribute_filters,
+            limit,
+            projection,
+            rls_filters,
+            prefilter,
+        } = params;
         debug!(
             core = self.core_id,
             %collection,
@@ -86,7 +120,7 @@ impl CoreLoop {
 
         // No R-tree: full scan with predicate post-filter.
         if !has_index {
-            return self.spatial_full_scan(
+            return self.spatial_full_scan(SpatialFullScanParams {
                 task,
                 tid,
                 collection,
@@ -96,10 +130,10 @@ impl CoreLoop {
                 distance_meters,
                 limit,
                 projection,
-                &attr_filters,
-                &row_level_filters,
+                attr_filters: &attr_filters,
+                rls_filters: &row_level_filters,
                 prefilter,
-            );
+            });
         }
 
         let coll_key = (db_id, tid_id, collection.to_string());
@@ -224,22 +258,21 @@ impl CoreLoop {
     }
 
     /// Full scan when no R-tree exists for the field.
-    #[allow(clippy::too_many_arguments)]
-    fn spatial_full_scan(
-        &self,
-        task: &ExecutionTask,
-        tid: u64,
-        collection: &str,
-        field: &str,
-        predicate: &SpatialPredicate,
-        query_geom: &nodedb_types::geometry::Geometry,
-        distance_meters: f64,
-        limit: usize,
-        projection: &[String],
-        attr_filters: &[ScanFilter],
-        rls_filters: &[ScanFilter],
-        prefilter: Option<&SurrogateBitmap>,
-    ) -> Response {
+    fn spatial_full_scan(&self, params: SpatialFullScanParams<'_>) -> Response {
+        let SpatialFullScanParams {
+            task,
+            tid,
+            collection,
+            field,
+            predicate,
+            query_geom,
+            distance_meters,
+            limit,
+            projection,
+            attr_filters,
+            rls_filters,
+            prefilter,
+        } = params;
         debug!(core = self.core_id, %collection, "spatial full scan (no R-tree index yet)");
 
         let scan_limit = limit * 10;
@@ -419,6 +452,7 @@ fn expand_bbox(bbox: &nodedb_types::BoundingBox, meters: f64) -> nodedb_types::B
 
 #[cfg(test)]
 mod tests {
+    use super::SpatialScanParams;
     use crate::bridge::envelope::{PhysicalPlan, Priority, Request, Status};
     use crate::data::executor::task::ExecutionTask;
     use crate::engine::spatial::RTreeEntry;
@@ -579,20 +613,20 @@ mod tests {
         let task = make_task(dummy_spatial_plan());
         let empty_bitmap = SurrogateBitmap::new();
 
-        let resp = core.execute_spatial_scan(
-            &task,
+        let resp = core.execute_spatial_scan(SpatialScanParams {
+            task: &task,
             tid,
             collection,
             field,
-            &nodedb_physical::physical_plan::SpatialPredicate::DWithin,
-            &origin_point(),
-            1_000_000.0,
-            &[],
-            100,
-            &[],
-            &[],
-            Some(&empty_bitmap),
-        );
+            predicate: &nodedb_physical::physical_plan::SpatialPredicate::DWithin,
+            query_geometry: &origin_point(),
+            distance_meters: 1_000_000.0,
+            attribute_filters: &[],
+            limit: 100,
+            projection: &[],
+            rls_filters: &[],
+            prefilter: Some(&empty_bitmap),
+        });
         assert_eq!(resp.status, Status::Ok);
         let decoded: Vec<nodedb_types::Value> =
             zerompk::from_msgpack(resp.payload.as_bytes()).unwrap_or_default();

nodedb/src/data/executor/handlers/vector_lifecycle.rs

@@ -11,6 +11,17 @@ use crate::bridge::envelope::{ErrorCode, Response};
 use crate::data::executor::core_loop::CoreLoop;
 use crate::data::executor::task::ExecutionTask;
 
+/// Parameters for [`CoreLoop::execute_vector_rebuild`].
+pub(in crate::data::executor) struct VectorRebuildParams<'a> {
+    pub task: &'a ExecutionTask,
+    pub tid: u64,
+    pub collection: &'a str,
+    pub field_name: &'a str,
+    pub m: usize,
+    pub m0: usize,
+    pub ef_construction: usize,
+}
+
 impl CoreLoop {
     /// Return live `VectorIndexStats` for a collection/field.
     ///
@@ -177,19 +188,22 @@ impl CoreLoop {
     /// Updates the params so future builds use them. Then re-seals and
     /// re-builds all sealed segments with the new params by extracting their
     /// vectors, creating new HNSW indexes, and swapping atomically.
-    #[allow(clippy::too_many_arguments)]
     pub(in crate::data::executor) fn execute_vector_rebuild(
         &mut self,
-        task: &ExecutionTask,
-        tid: u64,
-        collection: &str,
-        field_name: &str,
-        m: usize,
-        m0: usize,
-        ef_construction: usize,
+        params: VectorRebuildParams<'_>,
     ) -> Response {
         use crate::engine::vector::hnsw::{HnswIndex, HnswParams};
 
+        let VectorRebuildParams {
+            task,
+            tid,
+            collection,
+            field_name,
+            m,
+            m0,
+            ef_construction,
+        } = params;
+
         let database_id = task.request.database_id.as_u64();
         let index_key = CoreLoop::vector_index_key(database_id, tid, collection, field_name);
         debug!(