Method update_message_cas

crates/openshell-server/src/persistence/mod.rs:440–509

Update a protobuf message using CAS (compare-and-swap). Fetches the current object, validates the expected version, applies the mutation function, and attempts a single CAS write. Returns Conflict on version mismatch for caller-driven retry. # Arguments `id` - Object ID to update `expected_version` - Required resource version for the update to proceed. Pass 0 to use the current version (internal

(
        &self,
        id: &str,
        expected_version: u64,
        mut mutate: F,
    )

    /// * `Err(Conflict)` - Version mismatch; caller should retry
    /// * `Err(Database)` - Object not found or other DB error
    pub async fn update_message_cas<T, F>(
        &self,
        id: &str,
        expected_version: u64,
        mut mutate: F,
    ) -> PersistenceResult<T>
    where
        T: Message
            + Default
            + ObjectType
            + ObjectId
            + ObjectName
            + ObjectLabels
            + SetResourceVersion
            + GetResourceVersion
            + Clone,
        F: FnMut(&mut T),
    {
        // Fetch current object with authoritative resource_version
        let current = self
            .get_message::<T>(id)
            .await?
            .ok_or_else(|| PersistenceError::Database(format!("object {id} not found")))?;

        let current_version = current.get_resource_version();

        // Determine the version to use for CAS:
        // - If expected_version is 0, use current version (internal operations)
        // - Otherwise, validate that expected matches current (client-facing operations)
        let cas_version = if expected_version == 0 {
            current_version
        } else {
            if expected_version != current_version {
                return Err(PersistenceError::Conflict {
                    current_resource_version: Some(current_version),
                });
            }
            expected_version
        };

        // Apply mutation
        let mut updated = current.clone();
        mutate(&mut updated);

        // Serialize labels
        let labels_map = updated.object_labels();
        let labels_json = if labels_map.as_ref().is_none_or(HashMap::is_empty) {
            None
        } else {
            Some(serde_json::to_string(&labels_map).map_err(|e| {
                PersistenceError::Encode(format!("failed to serialize labels: {e}"))
            })?)
        };

        // Single-attempt CAS write - fails with Conflict on version mismatch
        let result = self
            .put_if(
                T::object_type(),