Improve "Video upload info not found" (#1116)

* wip

* fix merge conflict

* wip

* fix error handling

* format

* fix

* fix

Author: oscartbeaumont

apps/desktop/src-tauri/src/api.rs

@@ -5,9 +5,12 @@ use serde::{Deserialize, Serialize};
 use serde_json::json;
 use tauri::AppHandle;
 
-use crate::web_api::ManagerExt;
+use crate::web_api::{AuthedApiError, ManagerExt};
 
-pub async fn upload_multipart_initiate(app: &AppHandle, video_id: &str) -> Result<String, String> {
+pub async fn upload_multipart_initiate(
+    app: &AppHandle,
+    video_id: &str,
+) -> Result<String, AuthedApiError> {
     #[derive(Deserialize)]
     #[serde(rename_all = "camelCase")]
     pub struct Response {
@@ -32,14 +35,12 @@ pub async fn upload_multipart_initiate(app: &AppHandle, video_id: &str) -> Resul
             .text()
             .await
             .unwrap_or_else(|_| "<no response body>".to_string());
-        return Err(format!(
-            "api/upload_multipart_initiate/{status}: {error_body}"
-        ));
+        return Err(format!("api/upload_multipart_initiate/{status}: {error_body}").into());
     }
 
     resp.json::<Response>()
         .await
-        .map_err(|err| format!("api/upload_multipart_initiate/response: {err}"))
+        .map_err(|err| format!("api/upload_multipart_initiate/response: {err}").into())
         .map(|data| data.upload_id)
 }
 
@@ -49,7 +50,7 @@ pub async fn upload_multipart_presign_part(
     upload_id: &str,
     part_number: u32,
     md5_sum: &str,
-) -> Result<String, String> {
+) -> Result<String, AuthedApiError> {
     #[derive(Deserialize)]
     #[serde(rename_all = "camelCase")]
     pub struct Response {
@@ -76,14 +77,12 @@ pub async fn upload_multipart_presign_part(
             .text()
             .await
             .unwrap_or_else(|_| "<no response body>".to_string());
-        return Err(format!(
-            "api/upload_multipart_presign_part/{status}: {error_body}"
-        ));
+        return Err(format!("api/upload_multipart_presign_part/{status}: {error_body}").into());
     }
 
     resp.json::<Response>()
         .await
-        .map_err(|err| format!("api/upload_multipart_presign_part/response: {err}"))
+        .map_err(|err| format!("api/upload_multipart_presign_part/response: {err}").into())
         .map(|data| data.presigned_url)
 }
 
@@ -114,7 +113,7 @@ pub async fn upload_multipart_complete(
     upload_id: &str,
     parts: &[UploadedPart],
     meta: Option<S3VideoMeta>,
-) -> Result<Option<String>, String> {
+) -> Result<Option<String>, AuthedApiError> {
     #[derive(Serialize)]
     #[serde(rename_all = "camelCase")]
     pub struct MultipartCompleteRequest<'a> {
@@ -150,14 +149,12 @@ pub async fn upload_multipart_complete(
             .text()
             .await
             .unwrap_or_else(|_| "<no response body>".to_string());
-        return Err(format!(
-            "api/upload_multipart_complete/{status}: {error_body}"
-        ));
+        return Err(format!("api/upload_multipart_complete/{status}: {error_body}").into());
     }
 
     resp.json::<Response>()
         .await
-        .map_err(|err| format!("api/upload_multipart_complete/response: {err}"))
+        .map_err(|err| format!("api/upload_multipart_complete/response: {err}").into())
         .map(|data| data.location)
 }
 
@@ -179,7 +176,10 @@ pub struct PresignedS3PutRequest {
     pub meta: Option<S3VideoMeta>,
 }
 
-pub async fn upload_signed(app: &AppHandle, body: PresignedS3PutRequest) -> Result<String, String> {
+pub async fn upload_signed(
+    app: &AppHandle,
+    body: PresignedS3PutRequest,
+) -> Result<String, AuthedApiError> {
     #[derive(Deserialize)]
     struct Data {
         url: String,
@@ -204,12 +204,12 @@ pub async fn upload_signed(app: &AppHandle, body: PresignedS3PutRequest) -> Resu
             .text()
             .await
             .unwrap_or_else(|_| "<no response body>".to_string());
-        return Err(format!("api/upload_signed/{status}: {error_body}"));
+        return Err(format!("api/upload_signed/{status}: {error_body}").into());
     }
 
     resp.json::<Response>()
         .await
-        .map_err(|err| format!("api/upload_signed/response: {err}"))
+        .map_err(|err| format!("api/upload_signed/response: {err}").into())
         .map(|data| data.presigned_put_data.url)
 }
 
@@ -218,7 +218,7 @@ pub async fn desktop_video_progress(
     video_id: &str,
     uploaded: u64,
     total: u64,
-) -> Result<(), String> {
+) -> Result<(), AuthedApiError> {
     let resp = app
         .authed_api_request("/api/desktop/video/progress", |client, url| {
             client.post(url).json(&json!({
@@ -237,7 +237,7 @@ pub async fn desktop_video_progress(
             .text()
             .await
             .unwrap_or_else(|_| "<no response body>".to_string());
-        return Err(format!("api/desktop_video_progress/{status}: {error_body}"));
+        return Err(format!("api/desktop_video_progress/{status}: {error_body}").into());
     }
 
     Ok(())

apps/desktop/src-tauri/src/auth.rs

@@ -118,6 +118,3 @@ impl AuthStore {
         store.save().map_err(|e| e.to_string())
     }
 }
-
-#[derive(specta::Type, serde::Serialize, tauri_specta::Event, Debug, Clone, serde::Deserialize)]
-pub struct AuthenticationInvalid;

apps/desktop/src-tauri/src/deeplink_actions.rs

@@ -138,7 +138,9 @@ impl DeepLinkAction {
                     mode,
                 };
 
-                crate::recording::start_recording(app.clone(), state, inputs).await
+                crate::recording::start_recording(app.clone(), state, inputs)
+                    .await
+                    .map(|_| ())
             }
             DeepLinkAction::StopRecording => {
                 crate::recording::stop_recording(app.clone(), app.state()).await

apps/desktop/src-tauri/src/hotkeys.rs

@@ -146,9 +146,9 @@ async fn handle_hotkey(app: AppHandle, action: HotkeyAction) -> Result<(), Strin
             Ok(())
         }
         HotkeyAction::StopRecording => recording::stop_recording(app.clone(), app.state()).await,
-        HotkeyAction::RestartRecording => {
-            recording::restart_recording(app.clone(), app.state()).await
-        }
+        HotkeyAction::RestartRecording => recording::restart_recording(app.clone(), app.state())
+            .await
+            .map(|_| ()),
         HotkeyAction::OpenRecordingPicker => {
             let _ = RequestOpenRecordingPicker { target_mode: None }.emit(&app);
             Ok(())

apps/desktop/src-tauri/src/lib.rs

@@ -28,7 +28,7 @@ mod web_api;
 mod windows;
 
 use audio::AppSounds;
-use auth::{AuthStore, AuthenticationInvalid, Plan};
+use auth::{AuthStore, Plan};
 use camera::CameraPreviewState;
 use cap_editor::{EditorInstance, EditorState};
 use cap_project::{
@@ -87,6 +87,7 @@ use tokio::sync::Mutex;
 use tokio::sync::{RwLock, oneshot};
 use tracing::{error, trace, warn};
 use upload::{create_or_get_video, upload_image, upload_video};
+use web_api::AuthedApiError;
 use web_api::ManagerExt as WebManagerExt;
 use windows::{CapWindowId, EditorWindowIds, ShowCapWindow, set_window_transparent};
 
@@ -1084,7 +1085,7 @@ async fn upload_exported_video(
 
     channel.send(UploadProgress { progress: 0.0 }).ok();
 
-    let s3_config = async {
+    let s3_config = match async {
         let video_id = match mode {
             UploadMode::Initial { pre_created_video } => {
                 if let Some(pre_created) = pre_created_video {
@@ -1094,7 +1095,7 @@ async fn upload_exported_video(
             }
             UploadMode::Reupload => {
                 let Some(sharing) = meta.sharing.clone() else {
-                    return Err("No sharing metadata found".to_string());
+                    return Err("No sharing metadata found".into());
                 };
 
                 Some(sharing.id)
@@ -1110,7 +1111,13 @@ async fn upload_exported_video(
         )
         .await
     }
-    .await?;
+    .await
+    {
+        Ok(data) => data,
+        Err(AuthedApiError::InvalidAuthentication) => return Ok(UploadResult::NotAuthenticated),
+        Err(AuthedApiError::UpgradeRequired) => return Ok(UploadResult::UpgradeRequired),
+        Err(err) => return Err(err.to_string()),
+    };
 
     let screenshot_path = meta.project_path.join("screenshots/display.jpg");
     meta.upload = Some(UploadMeta::SinglePartUpload {
@@ -1154,17 +1161,20 @@ async fn upload_exported_video(
             NotificationType::ShareableLinkCopied.send(&app);
             Ok(UploadResult::Success(uploaded_video.link))
         }
+        Err(AuthedApiError::UpgradeRequired) => Ok(UploadResult::UpgradeRequired),
         Err(e) => {
             error!("Failed to upload video: {e}");
 
             NotificationType::UploadFailed.send(&app);
 
-            meta.upload = Some(UploadMeta::Failed { error: e.clone() });
+            meta.upload = Some(UploadMeta::Failed {
+                error: e.to_string(),
+            });
             meta.save_for_project()
                 .map_err(|e| error!("Failed to save recording meta: {e}"))
                 .ok();
 
-            Err(e)
+            Err(e.to_string().into())
         }
     }
 }
@@ -1597,16 +1607,10 @@ async fn check_upgraded_and_update(app: AppHandle) -> Result<bool, String> {
         .await
         .map_err(|e| {
             println!("Failed to fetch plan: {e}");
-            format!("Failed to fetch plan: {e}")
+            e.to_string()
         })?;
 
     println!("Plan fetch response status: {}", response.status());
-    if response.status() == reqwest::StatusCode::UNAUTHORIZED {
-        println!("Unauthorized response, clearing auth store");
-        AuthStore::set(&app, None).map_err(|e| e.to_string())?;
-        return Ok(false);
-    }
-
     let plan_data = response.json::<serde_json::Value>().await.map_err(|e| {
         println!("Failed to parse plan response: {e}");
         format!("Failed to parse plan response: {e}")
@@ -1998,7 +2002,6 @@ pub async fn run(recording_logging_handle: LoggingHandle) {
             RequestOpenSettings,
             RequestScreenCapturePrewarm,
             NewNotification,
-            AuthenticationInvalid,
             audio_meter::AudioInputLevelChange,
             captions::DownloadProgress,
             recording::RecordingEvent,
@@ -2548,7 +2551,7 @@ async fn resume_uploads(app: AppHandle) -> Result<(), String> {
                                         error!("Error completing resumed upload for video: {error}");
 
                                         if let Ok(mut meta) = RecordingMeta::load_for_project(&recording_dir).map_err(|err| error!("Error loading project metadata: {err}")) {
-                                            meta.upload = Some(UploadMeta::Failed { error });
+                                            meta.upload = Some(UploadMeta::Failed { error: error.to_string() });
                                             meta.save_for_project().map_err(|err| error!("Error saving project metadata: {err}")).ok();
                                         }
                                     })

apps/desktop/src-tauri/src/recording.rs

@@ -37,6 +37,7 @@ use tauri_plugin_dialog::{DialogExt, MessageDialogBuilder};
 use tauri_specta::Event;
 use tracing::*;
 
+use crate::web_api::AuthedApiError;
 use crate::{
     App, CurrentRecordingChanged, MutableState, NewStudioRecordingAdded, RecordingState,
     RecordingStopped, VideoUploadInfo,
@@ -245,14 +246,21 @@ pub enum RecordingEvent {
     Failed { error: String },
 }
 
+#[derive(Serialize, Type)]
+pub enum RecordingAction {
+    Started,
+    InvalidAuthentication,
+    UpgradeRequired,
+}
+
 #[tauri::command]
 #[specta::specta]
 #[tracing::instrument(name = "recording", skip_all)]
 pub async fn start_recording(
     app: AppHandle,
     state_mtx: MutableState<'_, App>,
     inputs: StartRecordingInputs,
-) -> Result<(), String> {
+) -> Result<RecordingAction, String> {
     if !matches!(state_mtx.read().await.recording_state, RecordingState::None) {
         return Err("Recording already in progress".to_string());
     }
@@ -294,7 +302,7 @@ pub async fn start_recording(
             match AuthStore::get(&app).ok().flatten() {
                 Some(_) => {
                     // Pre-create the video and get the shareable link
-                    let s3_config = create_or_get_video(
+                    let s3_config = match create_or_get_video(
                         &app,
                         false,
                         None,
@@ -305,10 +313,19 @@ pub async fn start_recording(
                         None,
                     )
                     .await
-                    .map_err(|err| {
-                        error!("Error creating instant mode video: {err}");
-                        err
-                    })?;
+                    {
+                        Ok(meta) => meta,
+                        Err(AuthedApiError::InvalidAuthentication) => {
+                            return Ok(RecordingAction::InvalidAuthentication);
+                        }
+                        Err(AuthedApiError::UpgradeRequired) => {
+                            return Ok(RecordingAction::UpgradeRequired);
+                        }
+                        Err(err) => {
+                            error!("Error creating instant mode video: {err}");
+                            return Err(err.to_string());
+                        }
+                    };
 
                     let link = app.make_app_url(format!("/s/{}", s3_config.id)).await;
                     info!("Pre-created shareable link: {}", link);
@@ -618,7 +635,7 @@ pub async fn start_recording(
 
     AppSounds::StartRecording.play();
 
-    Ok(())
+    Ok(RecordingAction::Started)
 }
 
 #[tauri::command]
@@ -663,7 +680,10 @@ pub async fn stop_recording(app: AppHandle, state: MutableState<'_, App>) -> Res
 
 #[tauri::command]
 #[specta::specta]
-pub async fn restart_recording(app: AppHandle, state: MutableState<'_, App>) -> Result<(), String> {
+pub async fn restart_recording(
+    app: AppHandle,
+    state: MutableState<'_, App>,
+) -> Result<RecordingAction, String> {
     let Some(recording) = state.write().await.clear_current_recording() else {
         return Err("No recording in progress".to_string());
     };
@@ -877,7 +897,7 @@ async fn handle_recording_finish(
                         .handle
                         .await
                         .map_err(|e| e.to_string())
-                        .and_then(|r| r)
+                        .and_then(|r| r.map_err(|v| v.to_string()))
                     {
                         Ok(()) => {
                             info!(
@@ -935,7 +955,9 @@ async fn handle_recording_finish(
                             error!("Error in upload_video: {error}");
 
                             if let Ok(mut meta) = RecordingMeta::load_for_project(&recording_dir) {
-                                meta.upload = Some(UploadMeta::Failed { error });
+                                meta.upload = Some(UploadMeta::Failed {
+                                    error: error.to_string(),
+                                });
                                 meta.save_for_project()
                                     .map_err(|e| format!("Failed to save recording meta: {e}"))
                                     .ok();