Please address the comments from this code review:

## Overall Comments
- For changed queries, consider updating the existing record (incrementing its HLC version) instead of delete+insert to preserve history.
- Use a named struct or type alias for the (operator, parameter) key rather than raw tuples to improve readability.

## Individual Comments

### Comment 1
<location> `database/src/actions/mixes.rs:324` </location>
<code_context>
-    for (operator, parameter) in &operator_parameters {
-        new_operator_params.insert(operator.clone(), parameter.clone());
-    }
+    // Create a set of new query keys for easy lookup
+    let new_query_keys: HashSet<(String, String)> = operator_parameters
+        .iter()
</code_context>

<issue_to_address>
**issue (complexity):** Consider replacing manual contains checks and loop nesting with set-difference iterations for clearer intent and simpler logic.

```markdown
You can collapse the two “contains + loop” phases into a pair of set‐difference iterations—this makes the intent clearer (insert what’s new, delete what’s gone) and removes manual `contains` checks inside loops:

```rust
// 1) build a map of existing (op,param) → Model
let existing_by_key = existing_queries
    .into_iter()
    .map(|q| ((q.operator.clone(), q.parameter.clone()), q))
    .collect::<HashMap<_, _>>();

// 2) collect sets of keys
let new_keys = operator_parameters
    .iter()
    .cloned()
    .collect::<HashSet<(String, String)>>();
let existing_keys = existing_by_key.keys().cloned().collect::<HashSet<_>>();

// 3) insert missing entries
for (operator, parameter) in new_keys.difference(&existing_keys) {
    let new_query = mix_queries::ActiveModel {
        mix_id: ActiveValue::Set(mix_id),
        operator: ActiveValue::Set(operator.clone()),
        parameter: ActiveValue::Set(parameter.clone()),
        /* … */
    };
    MixQueryEntity::insert(new_query)
        .exec(&txn).await
        .with_context(|| format!("Failed to insert `{operator}({parameter})`"))?;
}

// 4) delete stale entries
for key in existing_keys.difference(&new_keys) {
    let existing = &existing_by_key[key];
    MixQueryEntity::delete_by_id(existing.id)
        .exec(&txn).await
        .with_context(|| format!("Failed to delete `{}`", format!("{}({})", key.0, key.1)))?;
}
```

This drops the extra `new_query_keys` map and the `if/else` nesting. You still build exactly the same inserts/deletes, and you preserve all functionality.
</issue_to_address>

### Comment 2
<location> `database/src/actions/mixes.rs:382` </location>
<code_context>
existing_key.1
</code_context>

<issue_to_address>
**security (generic-api-key):** Detected a Generic API Key, potentially exposing access to various services and sensitive operations.

*Source: gitleaks*
</issue_to_address>