feat: sync_all and keep_local

Author: RobbyV2

app/page.tsx

@@ -395,6 +395,75 @@ function DeleteDialog({ prompt, onCancel, onConfirm }: DeleteDialogProps) {
   )
 }
 
+interface OverlapEntry {
+  id: number
+  name: string
+  ics_url: string
+  sync_all: boolean
+  keep_local: boolean
+}
+
+interface OverlapWarning {
+  overlapping: OverlapEntry[]
+  pendingSubmit: () => void
+}
+
+function OverlapWarningDialog({
+  warning,
+  onCancel,
+  onConfirm,
+}: {
+  warning: OverlapWarning | null
+  onCancel: () => void
+  onConfirm: () => void
+}) {
+  if (!warning) return null
+  return (
+    <div className="app-dialog show" onClick={onCancel}>
+      <div className="app-dialog-modal" onClick={e => e.stopPropagation()}>
+        <div className="app-dialog-header">
+          <h3>Duplicate Calendar Target</h3>
+        </div>
+        <div className="app-dialog-body">
+          <p>Another destination already syncs to this CalDAV calendar:</p>
+          {warning.overlapping.map(d => (
+            <div
+              key={d.id}
+              style={{
+                marginBottom: 8,
+                padding: '8px 12px',
+                background: 'var(--card-bg)',
+                borderRadius: 4,
+                border: '1px solid var(--card-border)',
+              }}
+            >
+              <strong>{d.name}</strong>
+              <br />
+              <span style={{ fontSize: 13, opacity: 0.7 }}>{d.ics_url}</span>
+              <br />
+              <span style={{ fontSize: 12, opacity: 0.6 }}>
+                sync_all: {d.sync_all ? 'on' : 'off'}, keep_local: {d.keep_local ? 'on' : 'off'}
+              </span>
+            </div>
+          ))}
+          <p style={{ marginTop: 12, fontSize: 13 }}>
+            Multiple destinations targeting the same calendar operate independently. If keep_local
+            is disabled on any destination, it may delete events uploaded by another.
+          </p>
+          <div className="dialog-actions">
+            <button className="app-btn app-btn-subtle" onClick={onCancel}>
+              Cancel
+            </button>
+            <button className="app-btn app-btn-primary" onClick={onConfirm}>
+              Continue Anyway
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}
+
 // --- Component ---
 
 export default function Home() {
@@ -431,6 +500,9 @@ export default function Home() {
   // Delete confirmation
   const [deletePrompt, setDeletePrompt] = useState<DeletePrompt | null>(null)
 
+  // Overlap warning
+  const [overlapWarning, setOverlapWarning] = useState<OverlapWarning | null>(null)
+
   // ── Data fetching ──────────────────────────────────────────────
 
   const fetchSources = useCallback(async () => {
@@ -606,17 +678,39 @@ export default function Home() {
 
   async function submitDest(e: React.FormEvent) {
     e.preventDefault()
-    const url = editingDest ? `/api/destinations/${editingDest.id}` : '/api/destinations'
-    const method = editingDest ? 'PUT' : 'POST'
     const { sync_interval_hours, sync_interval_minutes, sync_interval_seconds, ...rest } = destForm
     const body = {
       ...rest,
       sync_interval_secs: toSecs(sync_interval_hours, sync_interval_minutes, sync_interval_seconds),
     }
-    await apiSubmit(url, method, body, () => {
-      closeDestDialog()
-      fetchDestinations()
-    })
+
+    const doSubmit = async () => {
+      const url = editingDest ? `/api/destinations/${editingDest.id}` : '/api/destinations'
+      const method = editingDest ? 'PUT' : 'POST'
+      await apiSubmit(url, method, body, () => {
+        closeDestDialog()
+        fetchDestinations()
+      })
+      setOverlapWarning(null)
+    }
+
+    try {
+      const params = new URLSearchParams({
+        caldav_url: destForm.caldav_url,
+        calendar_name: destForm.calendar_name,
+      })
+      if (editingDest) params.set('exclude_id', String(editingDest.id))
+      const res = await api.get(`/api/destinations/check-overlap?${params}`)
+      const data = res.data as { overlapping: OverlapEntry[] }
+      if (data.overlapping?.length) {
+        setOverlapWarning({ overlapping: data.overlapping, pendingSubmit: doSubmit })
+        return
+      }
+    } catch {
+      // If overlap check fails, proceed without warning
+    }
+
+    await doSubmit()
   }
 
   // ── Delete handler ─────────────────────────────────────────────
@@ -1088,6 +1182,11 @@ export default function Home() {
         onCancel={() => setDeletePrompt(null)}
         onConfirm={handleDeleteConfirm}
       />
+      <OverlapWarningDialog
+        warning={overlapWarning}
+        onCancel={() => setOverlapWarning(null)}
+        onConfirm={() => overlapWarning?.pendingSubmit()}
+      />
     </div>
   )
 }

src/api/destinations.rs

@@ -5,7 +5,7 @@ use axum::{
     response::IntoResponse,
     routing::{delete, get, post, put},
 };
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use utoipa::ToSchema;
 
 use super::AppState;
@@ -31,13 +31,15 @@ pub struct ReverseSyncResult {
     message: String,
     uploaded: usize,
     skipped: usize,
+    deleted: usize,
     total: usize,
 }
 
 pub fn routes() -> Router<AppState> {
     Router::new()
         .route("/destinations", get(list_destinations))
         .route("/destinations", post(create_destination))
+        .route("/destinations/check-overlap", get(check_overlap))
         .route("/destinations/{id}", put(update_destination))
         .route("/destinations/{id}", delete(delete_destination))
         .route("/destinations/{id}/sync", post(sync_destination))
@@ -224,6 +226,7 @@ pub async fn sync_destination(
                         message: "Destination not found".into(),
                         uploaded: 0,
                         skipped: 0,
+                        deleted: 0,
                         total: 0,
                     }),
                 )
@@ -237,6 +240,7 @@ pub async fn sync_destination(
                         message: e.to_string(),
                         uploaded: 0,
                         skipped: 0,
+                        deleted: 0,
                         total: 0,
                     }),
                 )
@@ -256,20 +260,21 @@ pub async fn sync_destination(
     )
     .await
     {
-        Ok((uploaded, skipped, total)) => {
+        Ok(stats) => {
             let db = state.db.lock().unwrap();
             let _ = db::update_destination_sync_status(&db, id, "ok", None);
             (
                 StatusCode::OK,
                 Json(ReverseSyncResult {
                     status: "success".into(),
                     message: format!(
-                        "Uploaded {} of {} events ({} unchanged, skipped)",
-                        uploaded, total, skipped
+                        "Uploaded {} of {} events ({} unchanged, {} deleted)",
+                        stats.uploaded, stats.total, stats.skipped, stats.deleted
                     ),
-                    uploaded,
-                    skipped,
-                    total,
+                    uploaded: stats.uploaded,
+                    skipped: stats.skipped,
+                    deleted: stats.deleted,
+                    total: stats.total,
                 }),
             )
                 .into_response()
@@ -285,10 +290,66 @@ pub async fn sync_destination(
                     message: e.to_string(),
                     uploaded: 0,
                     skipped: 0,
+                    deleted: 0,
                     total: 0,
                 }),
             )
                 .into_response()
         }
     }
 }
+
+#[derive(Deserialize)]
+pub struct OverlapQuery {
+    caldav_url: String,
+    calendar_name: String,
+    exclude_id: Option<i64>,
+}
+
+#[derive(Serialize)]
+struct OverlapEntry {
+    id: i64,
+    name: String,
+    ics_url: String,
+    sync_all: bool,
+    keep_local: bool,
+}
+
+#[derive(Serialize)]
+struct OverlapResponse {
+    overlapping: Vec<OverlapEntry>,
+}
+
+pub async fn check_overlap(
+    State(state): State<AppState>,
+    axum::extract::Query(q): axum::extract::Query<OverlapQuery>,
+) -> impl IntoResponse {
+    let db = state.db.lock().unwrap();
+    match db::find_overlapping_destinations(&db, &q.caldav_url, &q.calendar_name, q.exclude_id) {
+        Ok(dests) => (
+            StatusCode::OK,
+            Json(OverlapResponse {
+                overlapping: dests
+                    .into_iter()
+                    .map(|d| OverlapEntry {
+                        id: d.id,
+                        name: d.name,
+                        ics_url: d.ics_url,
+                        sync_all: d.sync_all,
+                        keep_local: d.keep_local,
+                    })
+                    .collect(),
+            }),
+        )
+            .into_response(),
+        Err(e) => (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(DestinationResponse {
+                status: "error".into(),
+                message: e.to_string(),
+                destination: None,
+            }),
+        )
+            .into_response(),
+    }
+}