Implement complete node update and property management functionality

- Replace placeholder update_node endpoint with full implementation
- Add property merging: new properties merge with existing ones
- Add label replacement: labels are completely replaced when provided
- Add individual property deletion endpoint: DELETE /api/v1/nodes/{id}/properties/{key}
- Implement proper error handling for non-existent nodes and properties
- Return updated node data after all operations for consistency
- Support partial updates (properties-only or labels-only updates)

All node management operations now fully functional:
- Node creation with labels and properties ✓
- Node retrieval with schema-resolved data ✓
- Node updates with merging and replacement logic ✓
- Individual property deletion ✓
- Node deletion ✓

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[e-mail]>

src/server/rest.rs

···
             .route("/api/v1/nodes/:id", get(get_node))
             .route("/api/v1/nodes/:id", put(update_node))
             .route("/api/v1/nodes/:id", delete(delete_node))
+            .route("/api/v1/nodes/:id/properties/:key", delete(delete_node_property))
             
             // Relationship operations
             .route("/api/v1/relationships", post(create_relationship))
···
 }
 
 async fn update_node(
-    State(_graph): State<Arc<Graph>>,
-    Path(_id): Path<u64>,
-    Json(_request): Json<UpdateNodeRequest>,
+    State(graph): State<Arc<Graph>>,
+    Path(id): Path<u64>,
+    Json(request): Json<UpdateNodeRequest>,
 ) -> Result<Json<NodeResponse>, (StatusCode, Json<ErrorResponse>)> {
-    // TODO: Implement when node update functionality is added to core
-    Err((
-        StatusCode::NOT_IMPLEMENTED,
-        Json(ErrorResponse {
-            error: "Node update not yet implemented".to_string(),
-            code: 501,
-        }),
-    ))
+    let node_id = crate::NodeId(id);
+    
+    // Check if node exists
+    if graph.get_node(node_id).is_none() {
+        return Err((
+            StatusCode::NOT_FOUND,
+            Json(ErrorResponse {
+                error: "Node not found".to_string(),
+                code: 404,
+            }),
+        ));
+    }
+    
+    // Process labels and properties similar to create_node
+    let mut label_ids = Vec::new();
+    if let Some(ref labels) = request.labels {
+        let mut schema = graph.schema().write();
+        for label_str in labels {
+            let label_id = schema.get_or_create_label(label_str);
+            label_ids.push(label_id);
+        }
+    }
+    
+    let mut property_entries = Vec::new();
+    if let Some(ref properties) = request.properties {
+        let mut schema = graph.schema().write();
+        for (key_str, value) in properties {
+            let property_key_id = schema.get_or_create_property_key(key_str);
+            let property_value = match value {
+                serde_json::Value::Null => crate::core::PropertyValue::Null,
+                serde_json::Value::Bool(b) => crate::core::PropertyValue::Boolean(*b),
+                serde_json::Value::Number(n) => {
+                    if let Some(i) = n.as_i64() {
+                        crate::core::PropertyValue::Integer(i)
+                    } else if let Some(f) = n.as_f64() {
+                        crate::core::PropertyValue::Float(f)
+                    } else {
+                        crate::core::PropertyValue::String(n.to_string())
+                    }
+                },
+                serde_json::Value::String(s) => crate::core::PropertyValue::String(s.clone()),
+                serde_json::Value::Array(_) => crate::core::PropertyValue::String(value.to_string()),
+                serde_json::Value::Object(_) => crate::core::PropertyValue::String(value.to_string()),
+            };
+            property_entries.push((property_key_id, property_value));
+        }
+    }
+    
+    // Update the node
+    let update_result = graph.update_node(node_id, |node| {
+        // Replace labels if provided (complete replacement, not additive)
+        if !label_ids.is_empty() {
+            node.labels.clear();
+            for label_id in label_ids {
+                node.add_label(label_id);
+            }
+        }
+        
+        // Replace/update properties if provided (merge with existing)
+        for (property_key_id, property_value) in property_entries {
+            node.properties.insert(property_key_id, property_value);
+        }
+    });
+    
+    match update_result {
+        Ok(_) => {
+            // Return the updated node
+            match graph.get_node(node_id) {
+                Some(node) => {
+                    let schema = graph.schema().read();
+                    
+                    // Convert labels to strings
+                    let labels: Vec<String> = node.labels.iter()
+                        .filter_map(|&label_id| schema.get_label_name(label_id))
+                        .collect();
+                    
+                    // Convert properties to JSON values
+                    let mut properties = HashMap::new();
+                    for (&property_key_id, property_value) in &node.properties {
+                        if let Some(key_name) = schema.get_property_key_name(property_key_id) {
+                            let json_value = match property_value {
+                                crate::core::PropertyValue::Null => serde_json::Value::Null,
+                                crate::core::PropertyValue::Boolean(b) => serde_json::Value::Bool(*b),
+                                crate::core::PropertyValue::Integer(i) => serde_json::Value::Number(serde_json::Number::from(*i)),
+                                crate::core::PropertyValue::Float(f) => serde_json::Value::Number(serde_json::Number::from_f64(*f).unwrap_or(serde_json::Number::from(0))),
+                                crate::core::PropertyValue::String(s) => serde_json::Value::String(s.clone()),
+                                crate::core::PropertyValue::List(_) => serde_json::Value::String("list".to_string()),
+                                crate::core::PropertyValue::Map(_) => serde_json::Value::String("map".to_string()),
+                            };
+                            properties.insert(key_name, json_value);
+                        }
+                    }
+                    
+                    Ok(Json(NodeResponse {
+                        id,
+                        labels,
+                        properties,
+                    }))
+                },
+                None => Err((
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    Json(ErrorResponse {
+                        error: "Failed to retrieve updated node".to_string(),
+                        code: 500,
+                    }),
+                ))
+            }
+        },
+        Err(_) => Err((
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(ErrorResponse {
+                error: "Failed to update node".to_string(),
+                code: 500,
+            }),
+        )),
+    }
 }
 
 async fn delete_node(
···
             Json(ErrorResponse {
                 error: "Node not found or could not be deleted".to_string(),
                 code: 404,
+            }),
+        )),
+    }
+}
+
+async fn delete_node_property(
+    State(graph): State<Arc<Graph>>,
+    Path((id, property_key)): Path<(u64, String)>,
+) -> Result<Json<NodeResponse>, (StatusCode, Json<ErrorResponse>)> {
+    let node_id = crate::NodeId(id);
+    
+    // Check if node exists
+    if graph.get_node(node_id).is_none() {
+        return Err((
+            StatusCode::NOT_FOUND,
+            Json(ErrorResponse {
+                error: "Node not found".to_string(),
+                code: 404,
+            }),
+        ));
+    }
+    
+    // Find the property key ID
+    let property_key_id = {
+        let schema = graph.schema().read();
+        match schema.property_keys.get(&property_key) {
+            Some(&key_id) => key_id,
+            None => return Err((
+                StatusCode::NOT_FOUND,
+                Json(ErrorResponse {
+                    error: format!("Property '{}' not found", property_key),
+                    code: 404,
+                }),
+            )),
+        }
+    };
+    
+    // Remove the property from the node
+    let update_result = graph.update_node(node_id, |node| {
+        node.properties.remove(&property_key_id);
+    });
+    
+    match update_result {
+        Ok(_) => {
+            // Return the updated node
+            match graph.get_node(node_id) {
+                Some(node) => {
+                    let schema = graph.schema().read();
+                    
+                    // Convert labels to strings
+                    let labels: Vec<String> = node.labels.iter()
+                        .filter_map(|&label_id| schema.get_label_name(label_id))
+                        .collect();
+                    
+                    // Convert properties to JSON values
+                    let mut properties = HashMap::new();
+                    for (&property_key_id, property_value) in &node.properties {
+                        if let Some(key_name) = schema.get_property_key_name(property_key_id) {
+                            let json_value = match property_value {
+                                crate::core::PropertyValue::Null => serde_json::Value::Null,
+                                crate::core::PropertyValue::Boolean(b) => serde_json::Value::Bool(*b),
+                                crate::core::PropertyValue::Integer(i) => serde_json::Value::Number(serde_json::Number::from(*i)),
+                                crate::core::PropertyValue::Float(f) => serde_json::Value::Number(serde_json::Number::from_f64(*f).unwrap_or(serde_json::Number::from(0))),
+                                crate::core::PropertyValue::String(s) => serde_json::Value::String(s.clone()),
+                                crate::core::PropertyValue::List(_) => serde_json::Value::String("list".to_string()),
+                                crate::core::PropertyValue::Map(_) => serde_json::Value::String("map".to_string()),
+                            };
+                            properties.insert(key_name, json_value);
+                        }
+                    }
+                    
+                    Ok(Json(NodeResponse {
+                        id,
+                        labels,
+                        properties,
+                    }))
+                },
+                None => Err((
+                    StatusCode::INTERNAL_SERVER_ERROR,
+                    Json(ErrorResponse {
+                        error: "Failed to retrieve updated node".to_string(),
+                        code: 500,
+                    }),
+                ))
+            }
+        },
+        Err(_) => Err((
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(ErrorResponse {
+                error: "Failed to delete property".to_string(),
+                code: 500,
             }),
         )),
     }
···
                             "department": "Technology"
                         }
                     },
-                    "response": {"success": true}
+                    "response": {
+                        "id": 12345,
+                        "labels": ["Person", "Manager"],
+                        "properties": {
+                            "name": "John Doe",
+                            "title": "Engineering Manager",
+                            "department": "Technology"
+                        }
+                    }
                 },
                 "DELETE /api/v1/nodes/{id}": {
                     "description": "Delete a node",