feat(cli): Add batch splitting for code-mappings upload

Split large mapping files into batches of 300 (the backend limit)
per request. Each batch is sent sequentially with progress reporting.
Results are merged into a single summary table.

Batch-level HTTP failures are captured without aborting remaining
batches, and the final exit code reflects any errors.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: romtsn

src/api/data_types/code_mappings.rs

@@ -11,7 +11,7 @@ pub struct BulkCodeMappingsRequest {
     pub mappings: Vec<BulkCodeMapping>,
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct BulkCodeMapping {
     pub stack_root: String,

src/commands/code_mappings/upload.rs

@@ -4,11 +4,16 @@ use anyhow::{bail, Context as _, Result};
 use clap::{Arg, ArgMatches, Command};
 use log::debug;
 
-use crate::api::{Api, BulkCodeMapping, BulkCodeMappingsRequest};
+use crate::api::{
+    Api, BulkCodeMapping, BulkCodeMappingResult, BulkCodeMappingsRequest, BulkCodeMappingsResponse,
+};
 use crate::config::Config;
 use crate::utils::formatting::Table;
 use crate::utils::vcs;
 
+/// Maximum number of mappings the backend accepts per request.
+const BATCH_SIZE: usize = 300;
+
 pub fn make_command(command: Command) -> Command {
     command
         .about("Upload code mappings for a project from a JSON file.")
@@ -118,56 +123,95 @@ pub fn execute(matches: &ArgMatches) -> Result<()> {
     };
 
     let mapping_count = mappings.len();
-    let request = BulkCodeMappingsRequest {
-        project,
-        repository: repo_name,
-        default_branch,
-        mappings,
-    };
+    let batches: Vec<&[BulkCodeMapping]> = mappings.chunks(BATCH_SIZE).collect();
+    let total_batches = batches.len();
 
     println!("Uploading {mapping_count} code mapping(s)...");
 
     let api = Api::current();
-    let response = api
-        .authenticated()?
-        .bulk_upload_code_mappings(&org, &request)?;
+    let authenticated = api.authenticated()?;
 
-    // Display results
-    let mut table = Table::new();
-    table
-        .title_row()
-        .add("Stack Root")
-        .add("Source Root")
-        .add("Status");
-
-    for result in &response.mappings {
-        let status = match result.status.as_str() {
-            "error" => match &result.detail {
-                Some(detail) => format!("error: {detail}"),
-                None => "error".to_owned(),
-            },
-            s => s.to_owned(),
+    let mut merged = MergedResponse::default();
+
+    for (i, batch) in batches.iter().enumerate() {
+        if total_batches > 1 {
+            println!("Sending batch {}/{total_batches}...", i + 1);
+        }
+        let request = BulkCodeMappingsRequest {
+            project: project.clone(),
+            repository: repo_name.clone(),
+            default_branch: default_branch.clone(),
+            mappings: batch.to_vec(),
         };
+        match authenticated.bulk_upload_code_mappings(&org, &request) {
+            Ok(response) => merged.add(response),
+            Err(err) => {
+                merged
+                    .batch_errors
+                    .push(format!("Batch {}/{total_batches} failed: {err}", i + 1));
+            }
+        }
+    }
+
+    // Display results
+    if !merged.mappings.is_empty() {
+        let mut table = Table::new();
         table
-            .add_row()
-            .add(&result.stack_root)
-            .add(&result.source_root)
-            .add(&status);
+            .title_row()
+            .add("Stack Root")
+            .add("Source Root")
+            .add("Status");
+
+        for result in &merged.mappings {
+            let status = match result.status.as_str() {
+                "error" => match &result.detail {
+                    Some(detail) => format!("error: {detail}"),
+                    None => "error".to_owned(),
+                },
+                s => s.to_owned(),
+            };
+            table
+                .add_row()
+                .add(&result.stack_root)
+                .add(&result.source_root)
+                .add(&status);
+        }
+
+        table.print();
+        println!();
+    }
+
+    for err in &merged.batch_errors {
+        println!("{err}");
     }
 
-    table.print();
-    println!();
     println!(
         "Created: {}, Updated: {}, Errors: {}",
-        response.created, response.updated, response.errors
+        merged.created, merged.updated, merged.errors
     );
 
-    if response.errors > 0 {
-        bail!(
-            "{} mapping(s) failed to upload. See errors above.",
-            response.errors
-        );
+    if merged.errors > 0 || !merged.batch_errors.is_empty() {
+        let total_errors = merged.errors + merged.batch_errors.len() as u64;
+        bail!("{total_errors} error(s) during upload. See details above.");
     }
 
     Ok(())
 }
+
+#[derive(Default)]
+struct MergedResponse {
+    created: u64,
+    updated: u64,
+    errors: u64,
+    mappings: Vec<BulkCodeMappingResult>,
+    batch_errors: Vec<String>,
+}
+
+impl MergedResponse {
+    fn add(&mut self, response: BulkCodeMappingsResponse) {
+        self.created += response.created;
+        self.updated += response.updated;
+        self.errors += response.errors;
+        self.mappings.extend(response.mappings);
+    }
+}

tests/integration/code_mappings/upload.rs

@@ -1,15 +1,72 @@
-use crate::integration::{MockEndpointBuilder, TestManager};
+use std::sync::atomic::{AtomicU16, Ordering};
+
+use crate::integration::{AssertCommand, MockEndpointBuilder, TestManager};
 
 #[test]
 fn command_code_mappings_upload() {
     TestManager::new()
         .mock_endpoint(
-            MockEndpointBuilder::new(
-                "POST",
-                "/api/0/organizations/wat-org/code-mappings/bulk/",
-            )
-            .with_response_file("code_mappings/post-bulk.json"),
+            MockEndpointBuilder::new("POST", "/api/0/organizations/wat-org/code-mappings/bulk/")
+                .with_response_file("code_mappings/post-bulk.json"),
         )
         .register_trycmd_test("code_mappings/code-mappings-upload.trycmd")
         .with_default_token();
 }
+
+#[test]
+fn command_code_mappings_upload_batches() {
+    // Generate a fixture with 301 mappings to force 2 batches (300 + 1).
+    let mut mappings = Vec::with_capacity(301);
+    for i in 0..301 {
+        mappings.push(serde_json::json!({
+            "stackRoot": format!("com/example/m{i}"),
+            "sourceRoot": format!("modules/m{i}/src/main/java/com/example/m{i}"),
+        }));
+    }
+    let fixture = tempfile::NamedTempFile::new().expect("failed to create temp file");
+    serde_json::to_writer(&fixture, &mappings).expect("failed to write fixture");
+
+    let call_count = AtomicU16::new(0);
+
+    TestManager::new()
+        .mock_endpoint(
+            MockEndpointBuilder::new("POST", "/api/0/organizations/wat-org/code-mappings/bulk/")
+                .expect(2)
+                .with_response_fn(move |_request| {
+                    let n = call_count.fetch_add(1, Ordering::Relaxed);
+                    // Return appropriate counts per batch
+                    let (created, mapping_count) = if n == 0 { (300, 300) } else { (1, 1) };
+                    let mut batch_mappings = Vec::new();
+                    for i in 0..mapping_count {
+                        let idx = n as usize * 300 + i;
+                        batch_mappings.push(serde_json::json!({
+                        "stackRoot": format!("com/example/m{idx}"),
+                        "sourceRoot": format!("modules/m{idx}/src/main/java/com/example/m{idx}"),
+                        "status": "created",
+                    }));
+                    }
+                    serde_json::to_vec(&serde_json::json!({
+                        "created": created,
+                        "updated": 0,
+                        "errors": 0,
+                        "mappings": batch_mappings,
+                    }))
+                    .expect("failed to serialize response")
+                }),
+        )
+        .assert_cmd([
+            "code-mappings",
+            "upload",
+            fixture.path().to_str().expect("valid utf-8 path"),
+            "--org",
+            "wat-org",
+            "--project",
+            "wat-project",
+            "--repo",
+            "owner/repo",
+            "--default-branch",
+            "main",
+        ])
+        .with_default_token()
+        .run_and_assert(AssertCommand::Success);
+}