Add the overrideSettings parameter

crates/index-scheduler/src/scheduler/process_export.rs

@@ -59,42 +59,73 @@ impl IndexScheduler {
                 indexes.len() as u32,
             ));
 
-            let ExportIndexSettings { filter } = export_settings;
+            let ExportIndexSettings { filter, override_settings } = export_settings;
             let index = self.index(uid)?;
             let index_rtxn = index.read_txn()?;
 
-            // Send the primary key
+            let url = format!("{base_url}/indexes/{uid}");
+
+            // First, check if the index already exists
+            let response = retry(&must_stop_processing, || {
+                let mut request = agent.get(&url);
+                if let Some(api_key) = api_key {
+                    request = request.set("Authorization", &format!("Bearer {api_key}"));
+                }
+
+                request.send_string("").map_err(into_backoff_error)
+            })?;
+            let already_existed = response.status() == 200;
+
             let primary_key = index
                 .primary_key(&index_rtxn)
                 .map_err(|e| Error::from_milli(e.into(), Some(uid.to_string())))?;
 
-            let url = format!("{base_url}/indexes");
+            // Create the index
-            retry(&must_stop_processing, || {
+            if !already_existed {
-                let mut request = agent.post(&url);
+                let url = format!("{base_url}/indexes");
-                if let Some(api_key) = api_key {
+                retry(&must_stop_processing, || {
-                    request = request.set("Authorization", &format!("Bearer {api_key}"));
+                    let mut request = agent.post(&url);
-                }
+                    if let Some(api_key) = api_key {
-                let index_param = json!({ "uid": uid, "primaryKey": primary_key });
+                        request = request.set("Authorization", &format!("Bearer {api_key}"));
-                request.send_json(&index_param).map_err(into_backoff_error)
+                    }
-            })?;
+                    let index_param = json!({ "uid": uid, "primaryKey": primary_key });
+                    request.send_json(&index_param).map_err(into_backoff_error)
+                })?;
+            }
+
+            // Patch the index primary key
+            if already_existed && *override_settings {
+                let url = format!("{base_url}/indexes/{uid}");
+                retry(&must_stop_processing, || {
+                    let mut request = agent.patch(&url);
+                    if let Some(api_key) = api_key {
+                        request = request.set("Authorization", &format!("Bearer {api_key}"));
+                    }
+                    let index_param = json!({ "primaryKey": primary_key });
+                    request.send_json(&index_param).map_err(into_backoff_error)
+                })?;
+            }
 
             // Send the index settings
-            let mut settings = settings::settings(&index, &index_rtxn, SecretPolicy::RevealSecrets)
+            if !already_existed || *override_settings {
-                .map_err(|e| Error::from_milli(e, Some(uid.to_string())))?;
+                let mut settings =
-            // Remove the experimental chat setting if not enabled
+                    settings::settings(&index, &index_rtxn, SecretPolicy::RevealSecrets)
-            if self.features().check_chat_completions("exporting chat settings").is_err() {
+                        .map_err(|e| Error::from_milli(e, Some(uid.to_string())))?;
-                settings.chat = Setting::NotSet;
+                // Remove the experimental chat setting if not enabled
-            }
+                if self.features().check_chat_completions("exporting chat settings").is_err() {
-            // Retry logic for sending settings
+                    settings.chat = Setting::NotSet;
-            let url = format!("{base_url}/indexes/{uid}/settings");
-            let bearer = api_key.map(|api_key| format!("Bearer {api_key}"));
-            retry(&must_stop_processing, || {
-                let mut request = agent.patch(&url);
-                if let Some(bearer) = bearer.as_ref() {
-                    request = request.set("Authorization", bearer);
                 }
-                request.send_json(settings.clone()).map_err(into_backoff_error)
+                // Retry logic for sending settings
-            })?;
+                let url = format!("{base_url}/indexes/{uid}/settings");
+                let bearer = api_key.map(|api_key| format!("Bearer {api_key}"));
+                retry(&must_stop_processing, || {
+                    let mut request = agent.patch(&url);
+                    if let Some(bearer) = bearer.as_ref() {
+                        request = request.set("Authorization", bearer);
+                    }
+                    request.send_json(settings.clone()).map_err(into_backoff_error)
+                })?;
+            }
 
             let filter = filter
                 .as_ref()

crates/meilisearch-types/src/error.rs

@@ -395,6 +395,7 @@ InvalidExportApiKey                            , InvalidRequest       , BAD_REQU
 InvalidExportPayloadSize                       , InvalidRequest       , BAD_REQUEST ;
 InvalidExportIndexesPatterns                   , InvalidRequest       , BAD_REQUEST ;
 InvalidExportIndexFilter                       , InvalidRequest       , BAD_REQUEST ;
+InvalidExportIndexOverrideSettings             , InvalidRequest       , BAD_REQUEST ;
 // Experimental features - Chat Completions
 UnimplementedExternalFunctionCalling           , InvalidRequest       , NOT_IMPLEMENTED ;
 UnimplementedNonStreamingChatCompletions       , InvalidRequest       , NOT_IMPLEMENTED ;

crates/meilisearch-types/src/tasks.rs

@@ -178,6 +178,7 @@ pub struct IndexSwap {
 #[serde(rename_all = "camelCase")]
 pub struct ExportIndexSettings {
     pub filter: Option<Value>,
+    pub override_settings: bool,
 }
 
 impl KindWithContent {

crates/meilisearch/src/routes/export.rs

@@ -84,8 +84,8 @@ async fn export(
     let indexes = match indexes {
         Some(indexes) => indexes
             .into_iter()
-            .map(|(pattern, ExportIndexSettings { filter })| {
+            .map(|(pattern, ExportIndexSettings { filter, override_settings })| {
-                (pattern, DbExportIndexSettings { filter })
+                (pattern, DbExportIndexSettings { filter, override_settings })
             })
             .collect(),
         None => BTreeMap::from([(
@@ -179,4 +179,8 @@ pub struct ExportIndexSettings {
     #[serde(default)]
     #[deserr(default, error = DeserrJsonError<InvalidExportIndexFilter>)]
     pub filter: Option<Value>,
+    #[schema(value_type = Option<bool>, example = json!(true))]
+    #[serde(default)]
+    #[deserr(default, error = DeserrJsonError<InvalidExportIndexOverrideSettings>)]
+    pub override_settings: bool,
 }