refactor: update error handling in service and repository classes to use structured initialization for error messages, enhancing clarity and consistency across the codebase

Author: bialger

lib/vox_admin/admin_service.cpp

@@ -58,7 +58,7 @@ ServerStats AdminService::GetServerStats() {
 common::VoidResult AdminService::DeleteUser(const common::UserId& user_id) {
   auto user = users_.FindById(user_id);
   if (!user) {
-    return std::unexpected(common::Error{common::ErrorCode::kNotFound, "User not found"});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kNotFound, .message = "User not found"});
   }
 
   auto now = Now();
@@ -102,7 +102,7 @@ common::VoidResult AdminService::DeleteUser(const common::UserId& user_id) {
 
     txn.commit();
   } catch (const SQLite::Exception& e) {
-    return std::unexpected(common::Error{common::ErrorCode::kInternal, e.what()});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kInternal, .message = e.what()});
   }
 
   spdlog::info("User deleted: {} ({})", user->username, user_id);
@@ -112,7 +112,7 @@ common::VoidResult AdminService::DeleteUser(const common::UserId& user_id) {
 common::VoidResult AdminService::ForceLogout(const common::UserId& user_id) {
   auto user = users_.FindById(user_id);
   if (!user) {
-    return std::unexpected(common::Error{common::ErrorCode::kNotFound, "User not found"});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kNotFound, .message = "User not found"});
   }
   auto now = Now();
   auto revoke_result = sessions_.RevokeAllForUser(user_id, now);

lib/vox_attachments/attachment_service.cpp

@@ -21,20 +21,24 @@ common::Result<InitUploadResponse> AttachmentService::InitUpload(const common::U
                                                                  std::int64_t file_size,
                                                                  const std::string& mime_hint) {
   if (file_size <= 0) {
-    return std::unexpected(common::Error{common::ErrorCode::kInvalidArgument, "File size must be positive"});
+    return std::unexpected(
+        common::Error{.code = common::ErrorCode::kInvalidArgument, .message = "File size must be positive"});
   }
   if (file_size > static_cast<std::int64_t>(config_.max_upload_size_bytes)) {
-    return std::unexpected(common::Error{common::ErrorCode::kQuotaExceeded, "File exceeds maximum upload size"});
+    return std::unexpected(
+        common::Error{.code = common::ErrorCode::kQuotaExceeded, .message = "File exceeds maximum upload size"});
   }
 
   auto used = attachments_.GetStorageUsedByUser(user_id);
   if (used + file_size > static_cast<std::int64_t>(config_.max_storage_per_user_bytes)) {
-    return std::unexpected(common::Error{common::ErrorCode::kQuotaExceeded, "User storage quota exceeded"});
+    return std::unexpected(
+        common::Error{.code = common::ErrorCode::kQuotaExceeded, .message = "User storage quota exceeded"});
   }
 
   bool is_member = conversations_.IsUserInConversation(conversation_id, user_id);
   if (!is_member) {
-    return std::unexpected(common::Error{common::ErrorCode::kForbidden, "User is not a member of this conversation"});
+    return std::unexpected(
+        common::Error{.code = common::ErrorCode::kForbidden, .message = "User is not a member of this conversation"});
   }
 
   auto now = Now();
@@ -58,31 +62,32 @@ common::Result<InitUploadResponse> AttachmentService::InitUpload(const common::U
     return std::unexpected(result.error());
   }
 
-  return InitUploadResponse{attachment_id, blob_path.string()};
+  return InitUploadResponse{.attachment_id = attachment_id, .blob_path = blob_path.string()};
 }
 
 common::VoidResult AttachmentService::WriteChunk(const common::AttachmentId& attachment_id,
                                                  std::int64_t offset,
                                                  const std::string& data) {
   auto meta = attachments_.GetAttachmentMeta(attachment_id);
   if (!meta) {
-    return std::unexpected(common::Error{common::ErrorCode::kNotFound, "Attachment not found"});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kNotFound, .message = "Attachment not found"});
   }
   if (meta->upload_complete) {
-    return std::unexpected(common::Error{common::ErrorCode::kInvalidArgument, "Upload already complete"});
+    return std::unexpected(
+        common::Error{.code = common::ErrorCode::kInvalidArgument, .message = "Upload already complete"});
   }
 
   std::ofstream file(meta->blob_path, std::ios::binary | std::ios::in | std::ios::out);
   if (!file.is_open()) {
     file.open(meta->blob_path, std::ios::binary | std::ios::out);
   }
   if (!file.is_open()) {
-    return std::unexpected(common::Error{common::ErrorCode::kInternal, "Cannot open blob file"});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kInternal, .message = "Cannot open blob file"});
   }
   file.seekp(offset);
   file.write(data.data(), static_cast<std::streamsize>(data.size()));
   if (!file.good()) {
-    return std::unexpected(common::Error{common::ErrorCode::kInternal, "Failed to write chunk"});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kInternal, .message = "Failed to write chunk"});
   }
   return {};
 }
@@ -91,14 +96,16 @@ common::VoidResult AttachmentService::FinalizeUpload(const common::AttachmentId&
                                                      const std::string& ciphertext_hash) {
   auto meta = attachments_.GetAttachmentMeta(attachment_id);
   if (!meta) {
-    return std::unexpected(common::Error{common::ErrorCode::kNotFound, "Attachment not found"});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kNotFound, .message = "Attachment not found"});
   }
   if (meta->upload_complete) {
-    return std::unexpected(common::Error{common::ErrorCode::kInvalidArgument, "Upload already finalized"});
+    return std::unexpected(
+        common::Error{.code = common::ErrorCode::kInvalidArgument, .message = "Upload already finalized"});
   }
 
   if (!std::filesystem::exists(meta->blob_path)) {
-    return std::unexpected(common::Error{common::ErrorCode::kInternal, "Blob file not found on disk"});
+    return std::unexpected(
+        common::Error{.code = common::ErrorCode::kInternal, .message = "Blob file not found on disk"});
   }
 
   return attachments_.MarkUploadComplete(attachment_id, ciphertext_hash);
@@ -108,15 +115,17 @@ common::Result<std::filesystem::path> AttachmentService::GetAttachment(const com
                                                                        const common::UserId& user_id) {
   auto meta = attachments_.GetAttachmentMeta(attachment_id);
   if (!meta) {
-    return std::unexpected(common::Error{common::ErrorCode::kNotFound, "Attachment not found"});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kNotFound, .message = "Attachment not found"});
   }
   if (!meta->upload_complete) {
-    return std::unexpected(common::Error{common::ErrorCode::kNotFound, "Attachment upload not complete"});
+    return std::unexpected(
+        common::Error{.code = common::ErrorCode::kNotFound, .message = "Attachment upload not complete"});
   }
 
   bool is_member = conversations_.IsUserInConversation(meta->conversation_id, user_id);
   if (!is_member) {
-    return std::unexpected(common::Error{common::ErrorCode::kForbidden, "Not authorized to access this attachment"});
+    return std::unexpected(
+        common::Error{.code = common::ErrorCode::kForbidden, .message = "Not authorized to access this attachment"});
   }
 
   return std::filesystem::path(meta->blob_path);

lib/vox_auth/auth_service.cpp

@@ -18,12 +18,14 @@ AuthService::AuthService(store::UserRepository& users,
 
 common::Result<RegisterResponse> AuthService::Register(const RegisterRequest& request) {
   if (request.username.empty() || request.password_derived_value.empty()) {
-    return std::unexpected(common::Error{common::ErrorCode::kInvalidArgument, "Username and password are required"});
+    return std::unexpected(
+        common::Error{.code = common::ErrorCode::kInvalidArgument, .message = "Username and password are required"});
   }
 
   auto existing = users_.FindByUsername(request.username);
   if (existing) {
-    return std::unexpected(common::Error{common::ErrorCode::kAlreadyExists, "Username already taken"});
+    return std::unexpected(
+        common::Error{.code = common::ErrorCode::kAlreadyExists, .message = "Username already taken"});
   }
 
   auto hash_future = cpu_pool_.Submit([this, &request]() { return hasher_.Hash(request.password_derived_value); });
@@ -65,17 +67,17 @@ common::Result<RegisterResponse> AuthService::Register(const RegisterRequest& re
   }
 
   spdlog::info("User registered: {} ({})", request.username, user_id);
-  return RegisterResponse{user_id, *token_result};
+  return RegisterResponse{.user_id = user_id, .tokens = *token_result};
 }
 
 common::Result<LoginResponse> AuthService::Login(const LoginRequest& request) {
   auto user = users_.FindByUsername(request.username);
   if (!user) {
-    return std::unexpected(common::Error{common::ErrorCode::kUnauthorized, "Invalid credentials"});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kUnauthorized, .message = "Invalid credentials"});
   }
 
   if (user->disabled_at.has_value()) {
-    return std::unexpected(common::Error{common::ErrorCode::kForbidden, "Account is disabled"});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kForbidden, .message = "Account is disabled"});
   }
 
   auto verify_future = cpu_pool_.Submit([this, &request, &user]() {
@@ -84,7 +86,7 @@ common::Result<LoginResponse> AuthService::Login(const LoginRequest& request) {
   bool valid = verify_future.get();
 
   if (!valid) {
-    return std::unexpected(common::Error{common::ErrorCode::kUnauthorized, "Invalid credentials"});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kUnauthorized, .message = "Invalid credentials"});
   }
 
   auto now = Now();
@@ -107,7 +109,7 @@ common::Result<LoginResponse> AuthService::Login(const LoginRequest& request) {
   }
 
   spdlog::info("User logged in: {} ({})", request.username, user->user_id);
-  return LoginResponse{user->user_id, *token_result};
+  return LoginResponse{.user_id = user->user_id, .tokens = *token_result};
 }
 
 common::VoidResult AuthService::Logout(const std::string& session_id) {

lib/vox_auth/password_hasher.cpp

@@ -66,11 +66,12 @@ common::Result<HashResult> PasswordHasher::Hash(const std::string& password_deri
                                  hash_bytes.size());
 
   if (result != ARGON2_OK) {
-    return std::unexpected(common::Error{common::ErrorCode::kInternal,
-                                         fmt::format("Argon2 hash failed: {}", argon2_error_message(result))});
+    return std::unexpected(
+        common::Error{.code = common::ErrorCode::kInternal,
+                      .message = fmt::format("Argon2 hash failed: {}", argon2_error_message(result))});
   }
 
-  return HashResult{BytesToHex(salt_bytes), BytesToHex(hash_bytes)};
+  return HashResult{.salt = BytesToHex(salt_bytes), .verifier = BytesToHex(hash_bytes)};
 }
 
 bool PasswordHasher::Verify(const std::string& password_derived_value,

lib/vox_auth/token_manager.cpp

@@ -67,10 +67,10 @@ common::Result<store::SessionRecord> TokenManager::ValidateAccessToken(const std
   auto hash = HashToken(access_token);
   auto session = sessions_.FindByAccessToken(hash);
   if (!session) {
-    return std::unexpected(common::Error{common::ErrorCode::kUnauthorized, "Invalid access token"});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kUnauthorized, .message = "Invalid access token"});
   }
   if (session->access_expires_at <= now) {
-    return std::unexpected(common::Error{common::ErrorCode::kExpired, "Access token expired"});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kExpired, .message = "Access token expired"});
   }
   return *session;
 }
@@ -81,13 +81,14 @@ common::Result<TokenPair> TokenManager::RefreshTokens(const std::string& refresh
   auto hash = HashToken(refresh_token);
   auto session = sessions_.FindByRefreshToken(hash);
   if (!session) {
-    return std::unexpected(common::Error{common::ErrorCode::kUnauthorized, "Invalid refresh token"});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kUnauthorized, .message = "Invalid refresh token"});
   }
   if (session->refresh_expires_at <= now) {
-    return std::unexpected(common::Error{common::ErrorCode::kExpired, "Refresh token expired"});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kExpired, .message = "Refresh token expired"});
   }
   if (session->device_id != device_id) {
-    return std::unexpected(common::Error{common::ErrorCode::kForbidden, "Device mismatch on refresh"});
+    return std::unexpected(
+        common::Error{.code = common::ErrorCode::kForbidden, .message = "Device mismatch on refresh"});
   }
 
   auto revoke_result = sessions_.RevokeSession(session->session_id, now);

lib/vox_relay/delivery_manager.cpp

@@ -16,7 +16,8 @@ common::VoidResult DeliveryManager::Enqueue(const common::DeviceId& device_id, c
 
   if (queue.pending.size() >= max_queue_per_device_) {
     spdlog::warn("Queue overflow for device {}, switching to offline", device_id);
-    return std::unexpected(common::Error{common::ErrorCode::kQueueFull, "Device queue full, use offline delivery"});
+    return std::unexpected(
+        common::Error{.code = common::ErrorCode::kQueueFull, .message = "Device queue full, use offline delivery"});
   }
 
   queue.pending.push_back(envelope);

lib/vox_relay/relay_service.cpp

@@ -17,36 +17,39 @@ RelayService::RelayService(store::EnvelopeRepository& envelopes,
 
 common::Result<SendMessageResponse> RelayService::SendMessage(const SendMessageRequest& request) {
   if (request.ciphertext.empty()) {
-    return std::unexpected(common::Error{common::ErrorCode::kInvalidArgument, "Ciphertext is required"});
+    return std::unexpected(
+        common::Error{.code = common::ErrorCode::kInvalidArgument, .message = "Ciphertext is required"});
   }
 
   auto sender_device = devices_.FindById(request.sender_device_id);
   if (!sender_device) {
-    return std::unexpected(common::Error{common::ErrorCode::kUnauthorized, "Sender device not found"});
+    return std::unexpected(
+        common::Error{.code = common::ErrorCode::kUnauthorized, .message = "Sender device not found"});
   }
 
   auto conv = conversations_.FindById(request.conversation_id);
   if (!conv) {
-    return std::unexpected(common::Error{common::ErrorCode::kNotFound, "Conversation not found"});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kNotFound, .message = "Conversation not found"});
   }
 
   bool is_member = conversations_.IsUserInConversation(request.conversation_id, sender_device->user_id);
   if (!is_member) {
-    return std::unexpected(common::Error{common::ErrorCode::kForbidden, "Sender is not a member of this conversation"});
+    return std::unexpected(
+        common::Error{.code = common::ErrorCode::kForbidden, .message = "Sender is not a member of this conversation"});
   }
 
   if (conv->type == common::ConversationType::kChannel) {
     auto member = conversations_.GetMember(request.conversation_id, sender_device->user_id);
     if (!member || (member->role != common::MemberRole::kOwner && member->role != common::MemberRole::kAdmin)) {
-      return std::unexpected(
-          common::Error{common::ErrorCode::kForbidden, "Only admins/owners can publish to channels"});
+      return std::unexpected(common::Error{.code = common::ErrorCode::kForbidden,
+                                           .message = "Only admins/owners can publish to channels"});
     }
   }
 
   auto envelope_id = request.envelope_id.empty() ? common::GenerateUuid() : request.envelope_id;
 
   if (envelopes_.CheckDuplicate(envelope_id)) {
-    return std::unexpected(common::Error{common::ErrorCode::kDuplicate, "Duplicate envelope"});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kDuplicate, .message = "Duplicate envelope"});
   }
 
   auto now = Now();
@@ -99,7 +102,8 @@ common::Result<SendMessageResponse> RelayService::SendMessage(const SendMessageR
     }
   }
 
-  return SendMessageResponse{envelope_id, now, delivered_count};
+  return SendMessageResponse{
+      .envelope_id = envelope_id, .server_timestamp = now, .delivered_to_count = delivered_count};
 }
 
 std::vector<store::EnvelopeRecord> RelayService::SyncOffline(const common::DeviceId& device_id, std::size_t limit) {

lib/vox_store/attachment_repository.cpp

@@ -36,7 +36,7 @@ common::VoidResult AttachmentRepository::CreateAttachmentMeta(const AttachmentRe
     stmt.exec();
     return {};
   } catch (const SQLite::Exception& e) {
-    return std::unexpected(common::Error{common::ErrorCode::kInternal, e.what()});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kInternal, .message = e.what()});
   }
 }
 
@@ -73,7 +73,7 @@ common::VoidResult AttachmentRepository::MarkUploadComplete(const common::Attach
   stmt.bind(2, attachment_id);
   int rows = stmt.exec();
   if (rows == 0) {
-    return std::unexpected(common::Error{common::ErrorCode::kNotFound, "Attachment not found"});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kNotFound, .message = "Attachment not found"});
   }
   return {};
 }
@@ -84,7 +84,7 @@ common::VoidResult AttachmentRepository::DeleteAttachment(const common::Attachme
   stmt.bind(1, attachment_id);
   int rows = stmt.exec();
   if (rows == 0) {
-    return std::unexpected(common::Error{common::ErrorCode::kNotFound, "Attachment not found"});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kNotFound, .message = "Attachment not found"});
   }
   return {};
 }

lib/vox_store/conversation_repository.cpp

@@ -31,9 +31,10 @@ common::VoidResult ConversationRepository::CreateConversation(const Conversation
     return {};
   } catch (const SQLite::Exception& e) {
     if (e.getErrorCode() == SQLITE_CONSTRAINT) {
-      return std::unexpected(common::Error{common::ErrorCode::kAlreadyExists, "Conversation already exists"});
+      return std::unexpected(
+          common::Error{.code = common::ErrorCode::kAlreadyExists, .message = "Conversation already exists"});
     }
-    return std::unexpected(common::Error{common::ErrorCode::kInternal, e.what()});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kInternal, .message = e.what()});
   }
 }
 
@@ -72,7 +73,7 @@ common::VoidResult ConversationRepository::AddMember(const common::ConversationI
     stmt.exec();
     return {};
   } catch (const SQLite::Exception& e) {
-    return std::unexpected(common::Error{common::ErrorCode::kInternal, e.what()});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kInternal, .message = e.what()});
   }
 }
 
@@ -187,7 +188,7 @@ common::VoidResult ConversationRepository::Subscribe(const common::ConversationI
     stmt.exec();
     return {};
   } catch (const SQLite::Exception& e) {
-    return std::unexpected(common::Error{common::ErrorCode::kInternal, e.what()});
+    return std::unexpected(common::Error{.code = common::ErrorCode::kInternal, .message = e.what()});
   }
 }