sqlx prepare

fixes #145, related to #142

.github/workflows/docs.yml

@@ -17,6 +17,8 @@ jobs:
         with:
           python-version: 3.x
 
+      - run: rustup update
+
       - run: echo "cache_id=$(date --utc '+%V')" >> $GITHUB_ENV
 
       - name: Set up build cache

.sqlx/query-053c17f3b54ae3e153137926115486eb19a801bd73a74230bcf72a9a7254824a.json

@@ -0,0 +1,38 @@
+{
+  "db_name": "SQLite",
+  "query": "\n                SELECT principal, cal_id, id, (deleted_at IS NOT NULL) AS \"deleted: bool\"\n                    FROM calendarobjects\n                    WHERE (principal, cal_id, id) NOT IN (\n                        SELECT DISTINCT principal, cal_id, object_id FROM calendarobjectchangelog\n                    )\n                ;\n                ",
+  "describe": {
+    "columns": [
+      {
+        "name": "principal",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "cal_id",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "id",
+        "ordinal": 2,
+        "type_info": "Text"
+      },
+      {
+        "name": "deleted: bool",
+        "ordinal": 3,
+        "type_info": "Integer"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "053c17f3b54ae3e153137926115486eb19a801bd73a74230bcf72a9a7254824a"
+}

.sqlx/query-3a29efff3d3f6e1e05595d1a2d095af5fc963572c90bd10a6616af78757f8c39.json

@@ -0,0 +1,32 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT id, uid, ics FROM calendarobjects\n                WHERE principal = ? AND cal_id = ? AND deleted_at IS NULL\n                    AND (last_occurence IS NULL OR ? IS NULL OR last_occurence >= date(?))\n                    AND (first_occurence IS NULL OR ? IS NULL OR first_occurence <= date(?))\n            ",
+  "describe": {
+    "columns": [
+      {
+        "name": "id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "uid",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "ics",
+        "ordinal": 2,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 6
+    },
+    "nullable": [
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "3a29efff3d3f6e1e05595d1a2d095af5fc963572c90bd10a6616af78757f8c39"
+}

.sqlx/query-3e1cca532372e891ab3e604ecb79311d8cd64108d4f238db4c79e9467a3b6d2e.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "REPLACE INTO calendarobjects (principal, cal_id, id, ics, first_occurence, last_occurence, etag, object_type) VALUES (?, ?, ?, ?, date(?), date(?), ?, ?)",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 8
-    },
-    "nullable": []
-  },
-  "hash": "3e1cca532372e891ab3e604ecb79311d8cd64108d4f238db4c79e9467a3b6d2e"
-}

.sqlx/query-4a05eda4e23e8652312548b179a1cc16f43768074ab9e7ab7b7783395384984e.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "UPDATE birthday_calendars SET principal = ?, id = ?, displayname = ?, description = ?, \"order\" = ?, color = ?, timezone_id = ?, push_topic = ?\n                WHERE (principal, id) = (?, ?)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 10
+    },
+    "nullable": []
+  },
+  "hash": "4a05eda4e23e8652312548b179a1cc16f43768074ab9e7ab7b7783395384984e"
+}

.sqlx/query-505ebe8e64ac709b230dce7150240965e45442aca6c5f3b3115738ef508939ed.json

@@ -1,6 +1,6 @@
 {
   "db_name": "SQLite",
-  "query": "SELECT id, ics FROM calendarobjects WHERE (principal, cal_id, id) = (?, ?, ?) AND ((deleted_at IS NULL) OR ?)",
+  "query": "SELECT id, uid, ics FROM calendarobjects WHERE (principal, cal_id, id) = (?, ?, ?) AND ((deleted_at IS NULL) OR ?)",
   "describe": {
     "columns": [
       {
@@ -9,18 +9,24 @@
         "type_info": "Text"
       },
       {
-        "name": "ics",
+        "name": "uid",
         "ordinal": 1,
         "type_info": "Text"
+      },
+      {
+        "name": "ics",
+        "ordinal": 2,
+        "type_info": "Text"
       }
     ],
     "parameters": {
       "Right": 4
     },
     "nullable": [
+      false,
       false,
       false
     ]
   },
-  "hash": "543838c030550cb09d1af08adfeade8b7ce3575d92fddbc6e9582d141bc9e49d"
+  "hash": "505ebe8e64ac709b230dce7150240965e45442aca6c5f3b3115738ef508939ed"
 }

.sqlx/query-525fc4eab8a0f3eacff7e3c78ce809943f817abf8c8f9ae50073924bccdea2dc.json

@@ -0,0 +1,74 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT principal, id, displayname, description, \"order\", color, timezone_id, deleted_at, addr_synctoken, push_topic\n                FROM birthday_calendars\n                INNER JOIN (\n                    SELECT principal AS addr_principal,\n                        id AS addr_id,\n                        synctoken AS addr_synctoken\n                    FROM addressbooks\n                    ) ON (principal, id) = (addr_principal, addr_id)\n                WHERE (principal, id) = (?, ?)\n                AND ((deleted_at IS NULL) OR ?)\n            ",
+  "describe": {
+    "columns": [
+      {
+        "name": "principal",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "id",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "displayname",
+        "ordinal": 2,
+        "type_info": "Text"
+      },
+      {
+        "name": "description",
+        "ordinal": 3,
+        "type_info": "Text"
+      },
+      {
+        "name": "order",
+        "ordinal": 4,
+        "type_info": "Integer"
+      },
+      {
+        "name": "color",
+        "ordinal": 5,
+        "type_info": "Text"
+      },
+      {
+        "name": "timezone_id",
+        "ordinal": 6,
+        "type_info": "Text"
+      },
+      {
+        "name": "deleted_at",
+        "ordinal": 7,
+        "type_info": "Datetime"
+      },
+      {
+        "name": "addr_synctoken",
+        "ordinal": 8,
+        "type_info": "Integer"
+      },
+      {
+        "name": "push_topic",
+        "ordinal": 9,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 3
+    },
+    "nullable": [
+      false,
+      false,
+      true,
+      true,
+      false,
+      true,
+      true,
+      true,
+      false,
+      false
+    ]
+  },
+  "hash": "525fc4eab8a0f3eacff7e3c78ce809943f817abf8c8f9ae50073924bccdea2dc"
+}

.sqlx/query-6327bee90e5df01536a0ddb15adcc37af3027f6902aa3786365c5ab2fbf06bda.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "INSERT INTO calendarobjects (principal, cal_id, id, ics, first_occurence, last_occurence, etag, object_type) VALUES (?, ?, ?, ?, date(?), date(?), ?, ?)",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 8
-    },
-    "nullable": []
-  },
-  "hash": "6327bee90e5df01536a0ddb15adcc37af3027f6902aa3786365c5ab2fbf06bda"
-}

.sqlx/query-66d57f2c99ef37b383a478aff99110e1efbc7ce9332f10da4fa69f7594fb7455.json

@@ -0,0 +1,74 @@
+{
+  "db_name": "SQLite",
+  "query": "SELECT principal, id, displayname, description, \"order\", color, timezone_id, deleted_at, addr_synctoken, push_topic\n                FROM birthday_calendars\n                INNER JOIN (\n                    SELECT principal AS addr_principal,\n                        id AS addr_id,\n                        synctoken AS addr_synctoken\n                    FROM addressbooks\n                    ) ON (principal, id) = (addr_principal, addr_id)\n                WHERE principal = ?\n                AND (\n                    (deleted_at IS NULL AND NOT ?) -- not deleted, want not deleted\n                    OR (deleted_at IS NOT NULL AND ?) -- deleted, want deleted\n                )\n            ",
+  "describe": {
+    "columns": [
+      {
+        "name": "principal",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "id",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "displayname",
+        "ordinal": 2,
+        "type_info": "Text"
+      },
+      {
+        "name": "description",
+        "ordinal": 3,
+        "type_info": "Text"
+      },
+      {
+        "name": "order",
+        "ordinal": 4,
+        "type_info": "Integer"
+      },
+      {
+        "name": "color",
+        "ordinal": 5,
+        "type_info": "Text"
+      },
+      {
+        "name": "timezone_id",
+        "ordinal": 6,
+        "type_info": "Text"
+      },
+      {
+        "name": "deleted_at",
+        "ordinal": 7,
+        "type_info": "Datetime"
+      },
+      {
+        "name": "addr_synctoken",
+        "ordinal": 8,
+        "type_info": "Integer"
+      },
+      {
+        "name": "push_topic",
+        "ordinal": 9,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 3
+    },
+    "nullable": [
+      false,
+      false,
+      true,
+      true,
+      false,
+      true,
+      true,
+      true,
+      false,
+      false
+    ]
+  },
+  "hash": "66d57f2c99ef37b383a478aff99110e1efbc7ce9332f10da4fa69f7594fb7455"
+}

.sqlx/query-6c039308ad2ec29570ab492d7a0e85fb79c0a4d3b882b74ff1c2786c12324896.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "UPDATE birthday_calendars SET deleted_at = NULL WHERE (principal, id) = (?, ?)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": []
+  },
+  "hash": "6c039308ad2ec29570ab492d7a0e85fb79c0a4d3b882b74ff1c2786c12324896"
+}

.sqlx/query-72c7c67f4952ad669ecd54d96bbcb717815081f74575f0a65987163faf9fe30a.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "INSERT INTO birthday_calendars (principal, id, displayname, description, \"order\", color, push_topic)\n                VALUES (?, ?, ?, ?, ?, ?, ?)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 7
+    },
+    "nullable": []
+  },
+  "hash": "72c7c67f4952ad669ecd54d96bbcb717815081f74575f0a65987163faf9fe30a"
+}

.sqlx/query-804ed2a4a7032e9605d1871297498f5a96de0fc816ce660c705fb28318be0d42.json

@@ -1,6 +1,6 @@
 {
   "db_name": "SQLite",
-  "query": "SELECT id, ics FROM calendarobjects WHERE principal = ? AND cal_id = ? AND deleted_at IS NULL",
+  "query": "SELECT id, uid, ics FROM calendarobjects WHERE principal = ? AND cal_id = ? AND deleted_at IS NULL",
   "describe": {
     "columns": [
       {
@@ -9,18 +9,24 @@
         "type_info": "Text"
       },
       {
-        "name": "ics",
+        "name": "uid",
         "ordinal": 1,
         "type_info": "Text"
+      },
+      {
+        "name": "ics",
+        "ordinal": 2,
+        "type_info": "Text"
       }
     ],
     "parameters": {
       "Right": 2
     },
     "nullable": [
+      false,
       false,
       false
     ]
   },
-  "hash": "54c9c0e36a52e6963f11c6aa27f13aafb4204b8aa34b664fd825bd447db80e86"
+  "hash": "804ed2a4a7032e9605d1871297498f5a96de0fc816ce660c705fb28318be0d42"
 }

.sqlx/query-83f0aaf406785e323ac12019ac24f603c53125a1b2326f324c1e2d7b6c690adc.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "UPDATE birthday_calendars SET deleted_at = datetime() WHERE (principal, id) = (?, ?)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": []
+  },
+  "hash": "83f0aaf406785e323ac12019ac24f603c53125a1b2326f324c1e2d7b6c690adc"
+}

.sqlx/query-a68a1b96189b854a7ba2a3cd866ba583af5ad84bc1cd8b20cb805e9ce3bad820.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "REPLACE INTO calendarobjects (principal, cal_id, id, uid, ics, first_occurence, last_occurence, etag, object_type) VALUES (?, ?, ?, ?, ?, date(?), date(?), ?, ?)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 9
+    },
+    "nullable": []
+  },
+  "hash": "a68a1b96189b854a7ba2a3cd866ba583af5ad84bc1cd8b20cb805e9ce3bad820"
+}

.sqlx/query-c138b1143ac04af4930266ffae0990e82005911c11a683ad565e92335e085f4d.json

@@ -0,0 +1,38 @@
+{
+  "db_name": "SQLite",
+  "query": "\n                SELECT principal, addressbook_id, id, (deleted_at IS NOT NULL) AS \"deleted: bool\"\n                    FROM addressobjects\n                    WHERE (principal, addressbook_id, id) NOT IN (\n                        SELECT DISTINCT principal, addressbook_id, object_id FROM addressobjectchangelog\n                    )\n                ;\n                ",
+  "describe": {
+    "columns": [
+      {
+        "name": "principal",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "addressbook_id",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "id",
+        "ordinal": 2,
+        "type_info": "Text"
+      },
+      {
+        "name": "deleted: bool",
+        "ordinal": 3,
+        "type_info": "Integer"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "c138b1143ac04af4930266ffae0990e82005911c11a683ad565e92335e085f4d"
+}

.sqlx/query-c550dbf3d5ce7069f28d767ea9045e477ef8d29d6186851760757a06dec42339.json

@@ -1,26 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "SELECT id, ics FROM calendarobjects\n                WHERE principal = ? AND cal_id = ? AND deleted_at IS NULL\n                    AND (last_occurence IS NULL OR ? IS NULL OR last_occurence >= date(?))\n                    AND (first_occurence IS NULL OR ? IS NULL OR first_occurence <= date(?))\n            ",
-  "describe": {
-    "columns": [
-      {
-        "name": "id",
-        "ordinal": 0,
-        "type_info": "Text"
-      },
-      {
-        "name": "ics",
-        "ordinal": 1,
-        "type_info": "Text"
-      }
-    ],
-    "parameters": {
-      "Right": 6
-    },
-    "nullable": [
-      false,
-      false
-    ]
-  },
-  "hash": "c550dbf3d5ce7069f28d767ea9045e477ef8d29d6186851760757a06dec42339"
-}

.sqlx/query-cadc4ac16b7ac22b71c91ab36ad9dbb1dec943798d795fcbc811f4c651fea02a.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "DELETE FROM birthday_calendars WHERE (principal, id) = (?, ?)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 2
+    },
+    "nullable": []
+  },
+  "hash": "cadc4ac16b7ac22b71c91ab36ad9dbb1dec943798d795fcbc811f4c651fea02a"
+}

.sqlx/query-d498a758ed707408b00b7d2675250ea739a681ce1f009f05e97f2e101bd7e556.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "INSERT INTO calendarobjects (principal, cal_id, id, uid, ics, first_occurence, last_occurence, etag, object_type) VALUES (?, ?, ?, ?, ?, date(?), date(?), ?, ?)",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 9
+    },
+    "nullable": []
+  },
+  "hash": "d498a758ed707408b00b7d2675250ea739a681ce1f009f05e97f2e101bd7e556"
+}

Cargo.toml

@@ -2,7 +2,8 @@
 members = ["crates/*"]
 
 [workspace.package]
-version = "0.9.13"
+version = "0.10.5"
+rust-version = "1.91"
 edition = "2024"
 description = "A CalDAV server"
 documentation = "https://lennart-k.github.io/rustical/"
@@ -12,6 +13,7 @@ license = "AGPL-3.0-or-later"
 [package]
 name = "rustical"
 version.workspace = true
+rust-version.workspace = true
 edition.workspace = true
 description.workspace = true
 repository.workspace = true
@@ -35,6 +37,17 @@ opentelemetry = [
 debug = 0
 
 [workspace.dependencies]
+rustical_dav = { path = "./crates/dav/" }
+rustical_dav_push = { path = "./crates/dav_push/" }
+rustical_store = { path = "./crates/store/" }
+rustical_store_sqlite = { path = "./crates/store_sqlite/" }
+rustical_caldav = { path = "./crates/caldav/" }
+rustical_carddav = { path = "./crates/carddav/" }
+rustical_frontend = { path = "./crates/frontend/" }
+rustical_xml = { path = "./crates/xml/" }
+rustical_oidc = { path = "./crates/oidc/" }
+rustical_ical = { path = "./crates/ical/" }
+
 matchit = "0.9"
 uuid = { version = "1.11", features = ["v4", "fast-rng"] }
 async-trait = "0.1"
@@ -108,20 +121,10 @@ tower-http = { version = "0.6", features = [
   "catch-panic",
 ] }
 percent-encoding = "2.3"
-rustical_dav = { path = "./crates/dav/" }
-rustical_dav_push = { path = "./crates/dav_push/" }
-rustical_store = { path = "./crates/store/" }
-rustical_store_sqlite = { path = "./crates/store_sqlite/" }
-rustical_caldav = { path = "./crates/caldav/" }
-rustical_carddav = { path = "./crates/carddav/" }
-rustical_frontend = { path = "./crates/frontend/" }
-rustical_xml = { path = "./crates/xml/" }
-rustical_oidc = { path = "./crates/oidc/" }
-rustical_ical = { path = "./crates/ical/" }
 chrono-tz = "0.10"
 chrono-humanize = "0.2"
 rand = "0.9"
-axum-extra = { version = "0.10", features = ["typed-header"] }
+axum-extra = { version = "0.12", features = ["typed-header"] }
 rrule = "0.14"
 argon2 = "0.5"
 rpassword = "7.3"
@@ -130,7 +133,7 @@ syn = { version = "2.0", features = ["full"] }
 quote = "1.0"
 proc-macro2 = "1.0"
 heck = "0.5"
-darling = "0.21"
+darling = "0.23"
 reqwest = { version = "0.12", features = [
   "rustls-tls",
   "charset",
@@ -145,21 +148,22 @@ ece = { version = "2.3", default-features = false, features = [
 ] }
 openssl = { version = "0.10", features = ["vendored"] }
 async-std = { version = "1.13", features = ["attributes"] }
+similar-asserts = "1.7"
 
 [dependencies]
-rustical_store = { workspace = true }
+rustical_store.workspace = true
-rustical_store_sqlite = { workspace = true }
+rustical_store_sqlite.workspace = true
-rustical_caldav = { workspace = true }
+rustical_caldav.workspace = true
 rustical_carddav.workspace = true
-rustical_frontend = { workspace = true }
+rustical_frontend.workspace = true
-toml = { workspace = true }
+toml.workspace = true
-serde = { workspace = true }
+serde.workspace = true
-tokio = { workspace = true }
+tokio.workspace = true
-tracing = { workspace = true }
+tracing.workspace = true
-anyhow = { workspace = true }
+anyhow.workspace = true
 clap.workspace = true
-sqlx = { workspace = true }
+sqlx.workspace = true
-async-trait = { workspace = true }
+async-trait.workspace = true
 uuid.workspace = true
 axum.workspace = true
 

Dockerfile

@@ -1,4 +1,4 @@
-FROM --platform=$BUILDPLATFORM rust:1.90-alpine AS chef
+FROM --platform=$BUILDPLATFORM rust:1.91-alpine AS chef
 
 ARG TARGETPLATFORM
 ARG BUILDPLATFORM

crates/caldav/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "rustical_caldav"
 version.workspace = true
+rust-version.workspace = true
 edition.workspace = true
 description.workspace = true
 repository.workspace = true
@@ -17,21 +18,21 @@ serde_json.workspace = true
 axum.workspace = true
 axum-extra.workspace = true
 tower.workspace = true
-async-trait = { workspace = true }
+async-trait.workspace = true
-thiserror = { workspace = true }
+thiserror.workspace = true
-quick-xml = { workspace = true }
+quick-xml.workspace = true
-tracing = { workspace = true }
+tracing.workspace = true
-futures-util = { workspace = true }
+futures-util.workspace = true
-derive_more = { workspace = true }
+derive_more.workspace = true
-base64 = { workspace = true }
+base64.workspace = true
-serde = { workspace = true }
+serde.workspace = true
-tokio = { workspace = true }
+tokio.workspace = true
-url = { workspace = true }
+url.workspace = true
-rustical_dav = { workspace = true }
+rustical_dav.workspace = true
-rustical_store = { workspace = true }
+rustical_store.workspace = true
-chrono = { workspace = true }
+chrono.workspace = true
-chrono-tz = { workspace = true }
+chrono-tz.workspace = true
-sha2 = { workspace = true }
+sha2.workspace = true
 ical.workspace = true
 percent-encoding.workspace = true
 rustical_xml.workspace = true
@@ -44,3 +45,4 @@ tower-http.workspace = true
 strum.workspace = true
 strum_macros.workspace = true
 vtimezones-rs.workspace = true
+similar-asserts.workspace = true

crates/caldav/src/calendar/methods/import.rs

@@ -82,7 +82,7 @@ pub async fn route_import<C: CalendarStore, S: SubscriptionStore>(
     let objects = expanded_cals
         .into_iter()
         .map(|cal| cal.generate())
-        .map(CalendarObject::from_ics)
+        .map(|ics| CalendarObject::from_ics(ics, None))
         .collect::<Result<Vec<_>, _>>()?;
     let new_cal = Calendar {
         principal,

crates/caldav/src/calendar/methods/report/calendar_multiget.rs

@@ -26,16 +26,18 @@ pub async fn get_objects_calendar_multiget<C: CalendarStore>(
     let mut not_found = vec![];
 
     for href in &cal_query.href {
-        if let Some(filename) = href.strip_prefix(path) {
+        if let Ok(href) = percent_encoding::percent_decode_str(href).decode_utf8()
+            && let Some(filename) = href.strip_prefix(path)
+        {
             let filename = filename.trim_start_matches('/');
             if let Some(object_id) = filename.strip_suffix(".ics") {
                 match store.get_object(principal, cal_id, object_id, false).await {
                     Ok(object) => result.push(object),
-                    Err(rustical_store::Error::NotFound) => not_found.push(href.to_owned()),
+                    Err(rustical_store::Error::NotFound) => not_found.push(href.to_string()),
                     Err(err) => return Err(err.into()),
                 }
             } else {
-                not_found.push(href.to_owned());
+                not_found.push(href.to_string());
             }
         } else {
             not_found.push(href.to_owned());

crates/caldav/src/calendar/methods/report/calendar_query/comp_filter.rs

@@ -0,0 +1,345 @@
+use crate::calendar::methods::report::calendar_query::{
+    TimeRangeElement,
+    prop_filter::{PropFilterElement, PropFilterable},
+};
+use ical::parser::ical::component::IcalTimeZone;
+use rustical_ical::{CalendarObject, CalendarObjectComponent, CalendarObjectType};
+use rustical_xml::XmlDeserialize;
+
+#[derive(XmlDeserialize, Clone, Debug, PartialEq)]
+#[allow(dead_code)]
+// https://datatracker.ietf.org/doc/html/rfc4791#section-9.7.1
+pub struct CompFilterElement {
+    #[xml(ns = "rustical_dav::namespace::NS_CALDAV")]
+    pub(crate) is_not_defined: Option<()>,
+    #[xml(ns = "rustical_dav::namespace::NS_CALDAV")]
+    pub(crate) time_range: Option<TimeRangeElement>,
+    #[xml(ns = "rustical_dav::namespace::NS_CALDAV", flatten)]
+    pub(crate) prop_filter: Vec<PropFilterElement>,
+    #[xml(ns = "rustical_dav::namespace::NS_CALDAV", flatten)]
+    pub(crate) comp_filter: Vec<CompFilterElement>,
+
+    #[xml(ty = "attr")]
+    pub(crate) name: String,
+}
+
+pub trait CompFilterable: PropFilterable + Sized {
+    fn get_comp_name(&self) -> &'static str;
+
+    fn match_time_range(&self, time_range: &TimeRangeElement) -> bool;
+
+    fn match_subcomponents(&self, comp_filter: &CompFilterElement) -> bool;
+
+    // https://datatracker.ietf.org/doc/html/rfc4791#section-9.7.1
+    // The scope of the
+    // CALDAV:comp-filter XML element is the calendar object when used as
+    // a child of the CALDAV:filter XML element.  The scope of the
+    // CALDAV:comp-filter XML element is the enclosing calendar component
+    // when used as a child of another CALDAV:comp-filter XML element
+    fn matches(&self, comp_filter: &CompFilterElement) -> bool {
+        let name_matches = self.get_comp_name() == comp_filter.name;
+        match (comp_filter.is_not_defined.is_some(), name_matches) {
+            // We are the component that's not supposed to be defined
+            (true, true)
+            // We don't match
+            | (false, false) => return false,
+            // We shall not be and indeed we aren't
+            (true, false) => return true,
+            _ => {}
+        }
+
+        if let Some(time_range) = comp_filter.time_range.as_ref()
+            && !self.match_time_range(time_range)
+        {
+            return false;
+        }
+
+        for prop_filter in &comp_filter.prop_filter {
+            if !prop_filter.match_component(self) {
+                return false;
+            }
+        }
+
+        comp_filter
+            .comp_filter
+            .iter()
+            .all(|filter| self.match_subcomponents(filter))
+    }
+}
+
+impl CompFilterable for CalendarObject {
+    fn get_comp_name(&self) -> &'static str {
+        "VCALENDAR"
+    }
+
+    fn match_time_range(&self, _time_range: &TimeRangeElement) -> bool {
+        // VCALENDAR has no concept of time range
+        false
+    }
+
+    fn match_subcomponents(&self, comp_filter: &CompFilterElement) -> bool {
+        let mut matches = self
+            .get_vtimezones()
+            .values()
+            .map(|tz| tz.matches(comp_filter))
+            .chain([self.get_data().matches(comp_filter)]);
+
+        if comp_filter.is_not_defined.is_some() {
+            matches.all(|x| x)
+        } else {
+            matches.any(|x| x)
+        }
+    }
+}
+
+impl CompFilterable for IcalTimeZone {
+    fn get_comp_name(&self) -> &'static str {
+        "VTIMEZONE"
+    }
+
+    fn match_time_range(&self, _time_range: &TimeRangeElement) -> bool {
+        false
+    }
+
+    fn match_subcomponents(&self, _comp_filter: &CompFilterElement) -> bool {
+        true
+    }
+}
+
+impl CompFilterable for CalendarObjectComponent {
+    fn get_comp_name(&self) -> &'static str {
+        CalendarObjectType::from(self).as_str()
+    }
+
+    fn match_time_range(&self, time_range: &TimeRangeElement) -> bool {
+        if let Some(start) = &time_range.start
+            && let Some(last_occurence) = self.get_last_occurence().unwrap_or(None)
+            && **start > last_occurence.utc()
+        {
+            return false;
+        }
+        if let Some(end) = &time_range.end
+            && let Some(first_occurence) = self.get_first_occurence().unwrap_or(None)
+            && **end < first_occurence.utc()
+        {
+            return false;
+        }
+        true
+    }
+
+    fn match_subcomponents(&self, _comp_filter: &CompFilterElement) -> bool {
+        // TODO: Properly check subcomponents
+        true
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use chrono::{TimeZone, Utc};
+    use rustical_ical::{CalendarObject, UtcDateTime};
+
+    use crate::calendar::methods::report::calendar_query::{
+        CompFilterable, TextMatchElement, TimeRangeElement,
+        comp_filter::CompFilterElement,
+        prop_filter::PropFilterElement,
+        text_match::{NegateCondition, TextCollation},
+    };
+
+    const ICS: &str = r"BEGIN:VCALENDAR
+CALSCALE:GREGORIAN
+VERSION:2.0
+BEGIN:VTIMEZONE
+TZID:Europe/Berlin
+X-LIC-LOCATION:Europe/Berlin
+END:VTIMEZONE
+
+BEGIN:VEVENT
+UID:318ec6503573d9576818daf93dac07317058d95c
+DTSTAMP:20250502T132758Z
+DTSTART;TZID=Europe/Berlin:20250506T090000
+DTEND;TZID=Europe/Berlin:20250506T092500
+SEQUENCE:2
+SUMMARY:weekly stuff
+TRANSP:OPAQUE
+RRULE:FREQ=WEEKLY;COUNT=4;INTERVAL=2;BYDAY=TU,TH,SU
+END:VEVENT
+END:VCALENDAR";
+
+    #[test]
+    fn test_comp_filter_matching() {
+        let object = CalendarObject::from_ics(ICS.to_string(), None).unwrap();
+
+        let comp_filter = CompFilterElement {
+            is_not_defined: Some(()),
+            name: "VCALENDAR".to_string(),
+            time_range: None,
+            prop_filter: vec![],
+            comp_filter: vec![],
+        };
+        assert!(!object.matches(&comp_filter), "filter: wants no VCALENDAR");
+
+        let comp_filter = CompFilterElement {
+            is_not_defined: None,
+            name: "VCALENDAR".to_string(),
+            time_range: None,
+            prop_filter: vec![],
+            comp_filter: vec![CompFilterElement {
+                name: "VTODO".to_string(),
+                is_not_defined: None,
+                time_range: None,
+                prop_filter: vec![],
+                comp_filter: vec![],
+            }],
+        };
+        assert!(!object.matches(&comp_filter), "filter matches VTODO");
+
+        let comp_filter = CompFilterElement {
+            is_not_defined: None,
+            name: "VCALENDAR".to_string(),
+            time_range: None,
+            prop_filter: vec![],
+            comp_filter: vec![CompFilterElement {
+                name: "VEVENT".to_string(),
+                is_not_defined: None,
+                time_range: None,
+                prop_filter: vec![],
+                comp_filter: vec![],
+            }],
+        };
+        assert!(object.matches(&comp_filter), "filter matches VEVENT");
+
+        let comp_filter = CompFilterElement {
+            is_not_defined: None,
+            name: "VCALENDAR".to_string(),
+            time_range: None,
+            prop_filter: vec![
+                PropFilterElement {
+                    is_not_defined: None,
+                    name: "VERSION".to_string(),
+                    time_range: None,
+                    text_match: Some(TextMatchElement {
+                        needle: "2.0".to_string(),
+                        collation: TextCollation::default(),
+                        negate_condition: NegateCondition::default(),
+                    }),
+                    param_filter: vec![],
+                },
+                PropFilterElement {
+                    is_not_defined: Some(()),
+                    name: "STUFF".to_string(),
+                    time_range: None,
+                    text_match: None,
+                    param_filter: vec![],
+                },
+            ],
+            comp_filter: vec![CompFilterElement {
+                name: "VEVENT".to_string(),
+                is_not_defined: None,
+                time_range: None,
+                prop_filter: vec![PropFilterElement {
+                    is_not_defined: None,
+                    name: "SUMMARY".to_string(),
+                    time_range: None,
+                    text_match: Some(TextMatchElement {
+                        collation: TextCollation::default(),
+                        negate_condition: NegateCondition(false),
+                        needle: "weekly".to_string(),
+                    }),
+                    param_filter: vec![],
+                }],
+                comp_filter: vec![],
+            }],
+        };
+        assert!(
+            object.matches(&comp_filter),
+            "Some prop filters on VCALENDAR and VEVENT"
+        );
+    }
+    #[test]
+    fn test_comp_filter_time_range() {
+        let object = CalendarObject::from_ics(ICS.to_string(), None).unwrap();
+
+        let comp_filter = CompFilterElement {
+            is_not_defined: None,
+            name: "VCALENDAR".to_string(),
+            time_range: None,
+            prop_filter: vec![],
+            comp_filter: vec![CompFilterElement {
+                name: "VEVENT".to_string(),
+                is_not_defined: None,
+                time_range: Some(TimeRangeElement {
+                    start: Some(UtcDateTime(
+                        Utc.with_ymd_and_hms(2025, 4, 1, 0, 0, 0).unwrap(),
+                    )),
+                    end: Some(UtcDateTime(
+                        Utc.with_ymd_and_hms(2025, 8, 1, 0, 0, 0).unwrap(),
+                    )),
+                }),
+                prop_filter: vec![],
+                comp_filter: vec![],
+            }],
+        };
+        assert!(
+            object.matches(&comp_filter),
+            "event should lie in time range"
+        );
+
+        let comp_filter = CompFilterElement {
+            is_not_defined: None,
+            name: "VCALENDAR".to_string(),
+            time_range: None,
+            prop_filter: vec![],
+            comp_filter: vec![CompFilterElement {
+                name: "VEVENT".to_string(),
+                is_not_defined: None,
+                time_range: Some(TimeRangeElement {
+                    start: Some(UtcDateTime(
+                        Utc.with_ymd_and_hms(2024, 4, 1, 0, 0, 0).unwrap(),
+                    )),
+                    end: Some(UtcDateTime(
+                        Utc.with_ymd_and_hms(2024, 8, 1, 0, 0, 0).unwrap(),
+                    )),
+                }),
+                prop_filter: vec![],
+                comp_filter: vec![],
+            }],
+        };
+        assert!(
+            !object.matches(&comp_filter),
+            "event should not lie in time range"
+        );
+    }
+
+    #[test]
+    fn test_match_timezone() {
+        let object = CalendarObject::from_ics(ICS.to_string(), None).unwrap();
+
+        let comp_filter = CompFilterElement {
+            is_not_defined: None,
+            name: "VCALENDAR".to_string(),
+            time_range: None,
+            prop_filter: vec![],
+            comp_filter: vec![CompFilterElement {
+                name: "VTIMEZONE".to_string(),
+                is_not_defined: None,
+                time_range: None,
+                prop_filter: vec![PropFilterElement {
+                    is_not_defined: None,
+                    name: "TZID".to_string(),
+                    time_range: None,
+                    text_match: Some(TextMatchElement {
+                        collation: TextCollation::AsciiCasemap,
+                        negate_condition: NegateCondition::default(),
+                        needle: "Europe/Berlin".to_string(),
+                    }),
+                    param_filter: vec![],
+                }],
+                comp_filter: vec![],
+            }],
+        };
+        assert!(
+            object.matches(&comp_filter),
+            "Timezone should be Europe/Berlin"
+        );
+    }
+}

crates/caldav/src/calendar/methods/report/calendar_query/elements.rs

@@ -1,4 +1,10 @@
-use crate::calendar_object::CalendarObjectPropWrapperName;
+use crate::{
+    calendar::methods::report::calendar_query::{
+        TextMatchElement,
+        comp_filter::{CompFilterElement, CompFilterable},
+    },
+    calendar_object::CalendarObjectPropWrapperName,
+};
 use rustical_dav::xml::PropfindType;
 use rustical_ical::{CalendarObject, UtcDateTime};
 use rustical_store::calendar_store::CalendarQuery;
@@ -26,112 +32,6 @@ pub struct ParamFilterElement {
     pub(crate) name: String,
 }
 
-#[derive(XmlDeserialize, Clone, Debug, PartialEq, Eq)]
-#[allow(dead_code)]
-pub struct TextMatchElement {
-    #[xml(ty = "attr")]
-    pub(crate) collation: String,
-    #[xml(ty = "attr")]
-    // "yes" or "no", default: "no"
-    pub(crate) negate_condition: Option<String>,
-}
-
-#[derive(XmlDeserialize, Clone, Debug, PartialEq, Eq)]
-#[allow(dead_code)]
-// https://www.rfc-editor.org/rfc/rfc4791#section-9.7.2
-pub struct PropFilterElement {
-    #[xml(ns = "rustical_dav::namespace::NS_CALDAV")]
-    pub(crate) is_not_defined: Option<()>,
-    #[xml(ns = "rustical_dav::namespace::NS_CALDAV")]
-    pub(crate) time_range: Option<TimeRangeElement>,
-    #[xml(ns = "rustical_dav::namespace::NS_CALDAV")]
-    pub(crate) text_match: Option<TextMatchElement>,
-    #[xml(ns = "rustical_dav::namespace::NS_CALDAV", flatten)]
-    pub(crate) param_filter: Vec<ParamFilterElement>,
-
-    #[xml(ty = "attr")]
-    pub(crate) name: String,
-}
-
-#[derive(XmlDeserialize, Clone, Debug, PartialEq)]
-#[allow(dead_code)]
-// https://datatracker.ietf.org/doc/html/rfc4791#section-9.7.1
-pub struct CompFilterElement {
-    #[xml(ns = "rustical_dav::namespace::NS_CALDAV")]
-    pub(crate) is_not_defined: Option<()>,
-    #[xml(ns = "rustical_dav::namespace::NS_CALDAV")]
-    pub(crate) time_range: Option<TimeRangeElement>,
-    #[xml(ns = "rustical_dav::namespace::NS_CALDAV", flatten)]
-    pub(crate) prop_filter: Vec<PropFilterElement>,
-    #[xml(ns = "rustical_dav::namespace::NS_CALDAV", flatten)]
-    pub(crate) comp_filter: Vec<CompFilterElement>,
-
-    #[xml(ty = "attr")]
-    pub(crate) name: String,
-}
-
-impl CompFilterElement {
-    // match the VCALENDAR part
-    pub fn matches_root(&self, cal_object: &CalendarObject) -> bool {
-        let comp_vcal = self.name == "VCALENDAR";
-        match (self.is_not_defined, comp_vcal) {
-            // Client wants VCALENDAR to not exist but we are a VCALENDAR
-            (Some(()), true) |
-            // Client is asking for something different than a vcalendar
-            (None, false) => return false,
-            _ => {}
-        }
-
-        if self.time_range.is_some() {
-            // <time-range> should be applied on VEVENT/VTODO but not on VCALENDAR
-            return false;
-        }
-
-        // TODO: Implement prop-filter at some point
-
-        // Apply sub-comp-filters on VEVENT/VTODO/VJOURNAL component
-        if self
-            .comp_filter
-            .iter()
-            .all(|filter| filter.matches(cal_object))
-        {
-            return true;
-        }
-
-        false
-    }
-
-    // match the VEVENT/VTODO/VJOURNAL part
-    pub fn matches(&self, cal_object: &CalendarObject) -> bool {
-        let comp_name_matches = self.name == cal_object.get_component_name();
-        match (self.is_not_defined, comp_name_matches) {
-            // Client wants VCALENDAR to not exist but we are a VCALENDAR
-            (Some(()), true) |
-            // Client is asking for something different than a vcalendar
-            (None, false) => return false,
-            _ => {}
-        }
-
-        // TODO: Implement prop-filter (and comp-filter?) at some point
-
-        if let Some(time_range) = &self.time_range {
-            if let Some(start) = &time_range.start
-                && let Some(last_occurence) = cal_object.get_last_occurence().unwrap_or(None)
-                && **start > last_occurence.utc()
-            {
-                return false;
-            }
-            if let Some(end) = &time_range.end
-                && let Some(first_occurence) = cal_object.get_first_occurence().unwrap_or(None)
-                && **end < first_occurence.utc()
-            {
-                return false;
-            }
-        }
-        true
-    }
-}
-
 #[derive(XmlDeserialize, Clone, Debug, PartialEq)]
 #[allow(dead_code)]
 // https://datatracker.ietf.org/doc/html/rfc4791#section-9.7
@@ -142,8 +42,9 @@ pub struct FilterElement {
 }
 
 impl FilterElement {
+    #[must_use]
     pub fn matches(&self, cal_object: &CalendarObject) -> bool {
-        self.comp_filter.matches_root(cal_object)
+        cal_object.matches(&self.comp_filter)
     }
 }
 
@@ -187,3 +88,45 @@ impl From<&CalendarQueryRequest> for CalendarQuery {
         value.filter.as_ref().map(Self::from).unwrap_or_default()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::calendar::methods::report::calendar_query::{
+        CompFilterElement, FilterElement, TimeRangeElement,
+    };
+    use chrono::{NaiveDate, TimeZone, Utc};
+    use rustical_ical::UtcDateTime;
+    use rustical_store::calendar_store::CalendarQuery;
+
+    #[test]
+    fn test_filter_element_calendar_query() {
+        let filter = FilterElement {
+            comp_filter: CompFilterElement {
+                name: "VCALENDAR".to_string(),
+                is_not_defined: None,
+                time_range: None,
+                prop_filter: vec![],
+                comp_filter: vec![CompFilterElement {
+                    name: "VEVENT".to_string(),
+                    is_not_defined: None,
+                    time_range: Some(TimeRangeElement {
+                        start: Some(UtcDateTime(
+                            Utc.with_ymd_and_hms(2024, 4, 1, 0, 0, 0).unwrap(),
+                        )),
+                        end: Some(UtcDateTime(
+                            Utc.with_ymd_and_hms(2024, 8, 1, 0, 0, 0).unwrap(),
+                        )),
+                    }),
+                    prop_filter: vec![],
+                    comp_filter: vec![],
+                }],
+            },
+        };
+        let derived_query: CalendarQuery = (&filter).into();
+        let query = CalendarQuery {
+            time_start: Some(NaiveDate::from_ymd_opt(2024, 4, 1).unwrap()),
+            time_end: Some(NaiveDate::from_ymd_opt(2024, 8, 1).unwrap()),
+        };
+        assert_eq!(derived_query, query);
+    }
+}

crates/caldav/src/calendar/methods/report/calendar_query/mod.rs

@@ -2,8 +2,17 @@ use crate::Error;
 use rustical_ical::CalendarObject;
 use rustical_store::CalendarStore;
 
+mod comp_filter;
 mod elements;
+mod prop_filter;
+pub mod text_match;
+#[allow(unused_imports)]
+pub use comp_filter::{CompFilterElement, CompFilterable};
 pub use elements::*;
+#[allow(unused_imports)]
+pub use prop_filter::{PropFilterElement, PropFilterable};
+#[allow(unused_imports)]
+pub use text_match::TextMatchElement;
 
 pub async fn get_objects_calendar_query<C: CalendarStore>(
     cal_query: &CalendarQueryRequest,
@@ -29,8 +38,10 @@ mod tests {
         calendar::methods::report::{
             ReportRequest,
             calendar_query::{
-                CalendarQueryRequest, CompFilterElement, FilterElement, ParamFilterElement,
+                CalendarQueryRequest, FilterElement, ParamFilterElement, TextMatchElement,
-                PropFilterElement, TextMatchElement,
+                comp_filter::CompFilterElement,
+                prop_filter::PropFilterElement,
+                text_match::{NegateCondition, TextCollation},
             },
         },
         calendar_object::{CalendarData, CalendarObjectPropName, CalendarObjectPropWrapperName},
@@ -90,16 +101,18 @@ mod tests {
                             prop_filter: vec![PropFilterElement {
                                 name: "ATTENDEE".to_owned(),
                                 text_match: Some(TextMatchElement {
-                                    collation: "i;ascii-casemap".to_owned(),
+                                    collation: TextCollation::AsciiCasemap,
-                                    negate_condition: None
+                                    negate_condition: NegateCondition(false),
+                                    needle: "mailto:lisa@example.com".to_string()
                                 }),
                                 is_not_defined: None,
                                 param_filter: vec![ParamFilterElement {
                                     is_not_defined: None,
                                     name: "PARTSTAT".to_owned(),
                                     text_match: Some(TextMatchElement {
-                                        collation: "i;ascii-casemap".to_owned(),
+                                        collation: TextCollation::AsciiCasemap,
-                                        negate_condition: None
+                                        negate_condition: NegateCondition(false),
+                                        needle: "NEEDS-ACTION".to_string()
                                     }),
                                 }],
                                 time_range: None

crates/caldav/src/calendar/methods/report/calendar_query/prop_filter.rs

@@ -0,0 +1,127 @@
+use std::collections::HashMap;
+
+use ical::{
+    generator::{IcalCalendar, IcalEvent},
+    parser::{
+        Component,
+        ical::component::{IcalJournal, IcalTimeZone, IcalTodo},
+    },
+    property::Property,
+};
+use rustical_ical::{CalDateTime, CalendarObject, CalendarObjectComponent, UtcDateTime};
+use rustical_xml::XmlDeserialize;
+
+use crate::calendar::methods::report::calendar_query::{
+    ParamFilterElement, TextMatchElement, TimeRangeElement,
+};
+
+#[derive(XmlDeserialize, Clone, Debug, PartialEq, Eq)]
+#[allow(dead_code)]
+// https://www.rfc-editor.org/rfc/rfc4791#section-9.7.2
+pub struct PropFilterElement {
+    #[xml(ns = "rustical_dav::namespace::NS_CALDAV")]
+    pub(crate) is_not_defined: Option<()>,
+    #[xml(ns = "rustical_dav::namespace::NS_CALDAV")]
+    pub(crate) time_range: Option<TimeRangeElement>,
+    #[xml(ns = "rustical_dav::namespace::NS_CALDAV")]
+    pub(crate) text_match: Option<TextMatchElement>,
+    #[xml(ns = "rustical_dav::namespace::NS_CALDAV", flatten)]
+    pub(crate) param_filter: Vec<ParamFilterElement>,
+
+    #[xml(ty = "attr")]
+    pub(crate) name: String,
+}
+
+impl PropFilterElement {
+    pub fn match_component(&self, comp: &impl PropFilterable) -> bool {
+        let property = comp.get_property(&self.name);
+        let property = match (self.is_not_defined.is_some(), property) {
+            // We are the component that's not supposed to be defined
+            (true, Some(_))
+            // We don't match
+            | (false, None) => return false,
+            // We shall not be and indeed we aren't
+            (true, None) => return true,
+            (false, Some(property)) => property
+        };
+
+        if let Some(TimeRangeElement { start, end }) = &self.time_range {
+            // TODO: Respect timezones
+            let Ok(timestamp) = CalDateTime::parse_prop(property, &HashMap::default()) else {
+                return false;
+            };
+            let timestamp = timestamp.utc();
+            if let Some(UtcDateTime(start)) = start
+                && start > &timestamp
+            {
+                return false;
+            }
+            if let Some(UtcDateTime(end)) = end
+                && end < &timestamp
+            {
+                return false;
+            }
+            return true;
+        }
+
+        if let Some(text_match) = &self.text_match
+            && !text_match.match_property(property)
+        {
+            return false;
+        }
+
+        // TODO: param-filter
+
+        true
+    }
+}
+
+pub trait PropFilterable {
+    fn get_property(&self, name: &str) -> Option<&Property>;
+}
+
+impl PropFilterable for CalendarObject {
+    fn get_property(&self, name: &str) -> Option<&Property> {
+        Self::get_property(self, name)
+    }
+}
+
+impl PropFilterable for IcalEvent {
+    fn get_property(&self, name: &str) -> Option<&Property> {
+        Component::get_property(self, name)
+    }
+}
+
+impl PropFilterable for IcalTodo {
+    fn get_property(&self, name: &str) -> Option<&Property> {
+        Component::get_property(self, name)
+    }
+}
+
+impl PropFilterable for IcalJournal {
+    fn get_property(&self, name: &str) -> Option<&Property> {
+        Component::get_property(self, name)
+    }
+}
+
+impl PropFilterable for IcalCalendar {
+    fn get_property(&self, name: &str) -> Option<&Property> {
+        Component::get_property(self, name)
+    }
+}
+
+impl PropFilterable for IcalTimeZone {
+    fn get_property(&self, name: &str) -> Option<&Property> {
+        Component::get_property(self, name)
+    }
+}
+
+impl PropFilterable for CalendarObjectComponent {
+    fn get_property(&self, name: &str) -> Option<&Property> {
+        match self {
+            Self::Event(event, _) => PropFilterable::get_property(&event.event, name),
+            Self::Todo(todo, _) => PropFilterable::get_property(todo, name),
+            Self::Journal(journal, _) => PropFilterable::get_property(journal, name),
+        }
+    }
+}

crates/caldav/src/calendar/methods/report/calendar_query/text_match.rs

@@ -0,0 +1,103 @@
+use ical::property::Property;
+use rustical_xml::{ValueDeserialize, XmlDeserialize};
+
+#[derive(Clone, Debug, PartialEq, Eq, Default)]
+pub enum TextCollation {
+    #[default]
+    AsciiCasemap,
+    Octet,
+}
+
+impl TextCollation {
+    // Check whether a haystack contains a needle respecting the collation
+    #[must_use]
+    pub fn match_text(&self, needle: &str, haystack: &str) -> bool {
+        match self {
+            // https://datatracker.ietf.org/doc/html/rfc4790#section-9.2
+            Self::AsciiCasemap => haystack
+                .to_ascii_uppercase()
+                .contains(&needle.to_ascii_uppercase()),
+            Self::Octet => haystack.contains(needle),
+        }
+    }
+}
+
+impl AsRef<str> for TextCollation {
+    fn as_ref(&self) -> &str {
+        match self {
+            Self::AsciiCasemap => "i;ascii-casemap",
+            Self::Octet => "i;octet",
+        }
+    }
+}
+
+impl ValueDeserialize for TextCollation {
+    fn deserialize(val: &str) -> Result<Self, rustical_xml::XmlError> {
+        match val {
+            "i;ascii-casemap" => Ok(Self::AsciiCasemap),
+            "i;octet" => Ok(Self::Octet),
+            _ => Err(rustical_xml::XmlError::InvalidVariant(format!(
+                "Invalid collation: {val}"
+            ))),
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Default)]
+pub struct NegateCondition(pub bool);
+
+impl ValueDeserialize for NegateCondition {
+    fn deserialize(val: &str) -> Result<Self, rustical_xml::XmlError> {
+        match val {
+            "yes" => Ok(Self(true)),
+            "no" => Ok(Self(false)),
+            _ => Err(rustical_xml::XmlError::InvalidVariant(format!(
+                "Invalid negate-condition parameter: {val}"
+            ))),
+        }
+    }
+}
+
+#[derive(XmlDeserialize, Clone, Debug, PartialEq, Eq)]
+#[allow(dead_code)]
+pub struct TextMatchElement {
+    #[xml(ty = "attr", default = "Default::default")]
+    pub collation: TextCollation,
+    #[xml(ty = "attr", default = "Default::default")]
+    pub(crate) negate_condition: NegateCondition,
+    #[xml(ty = "text")]
+    pub(crate) needle: String,
+}
+
+impl TextMatchElement {
+    #[must_use]
+    pub fn match_property(&self, property: &Property) -> bool {
+        let Self {
+            collation,
+            negate_condition,
+            needle,
+        } = self;
+
+        let matches = property
+            .value
+            .as_ref()
+            .is_some_and(|haystack| collation.match_text(needle, haystack));
+
+        // XOR
+        negate_condition.0 ^ matches
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::calendar::methods::report::calendar_query::text_match::TextCollation;
+
+    #[test]
+    fn test_collation() {
+        assert!(TextCollation::AsciiCasemap.match_text("GrüN", "grün"));
+        assert!(!TextCollation::AsciiCasemap.match_text("GrÜN", "grün"));
+        assert!(!TextCollation::Octet.match_text("GrÜN", "grün"));
+        assert!(TextCollation::Octet.match_text("hallo", "hallo"));
+        assert!(TextCollation::AsciiCasemap.match_text("HaLlo", "hAllo"));
+    }
+}

crates/caldav/src/calendar/methods/report/mod.rs

@@ -27,7 +27,7 @@ use sync_collection::handle_sync_collection;
 use tracing::instrument;
 
 mod calendar_multiget;
-mod calendar_query;
+pub mod calendar_query;
 mod sync_collection;
 
 #[derive(XmlDeserialize, XmlDocument, Clone, Debug, PartialEq)]

crates/caldav/src/calendar/prop.rs

@@ -3,6 +3,8 @@ use rustical_ical::CalendarObjectType;
 use rustical_xml::{XmlDeserialize, XmlSerialize};
 use strum_macros::VariantArray;
 
+use crate::calendar::methods::report::calendar_query::text_match::TextCollation;
+
 #[derive(Debug, Clone, XmlSerialize, XmlDeserialize, PartialEq, Eq, From, Into)]
 pub struct SupportedCalendarComponent {
     #[xml(ty = "attr")]
@@ -36,6 +38,28 @@ impl From<SupportedCalendarComponentSet> for Vec<CalendarObjectType> {
     }
 }
 
+#[derive(Debug, Clone, XmlSerialize, XmlDeserialize, PartialEq, Eq, From, Into)]
+pub struct SupportedCollation(#[xml(ty = "text")] pub TextCollation);
+
+#[derive(Debug, Clone, XmlSerialize, XmlDeserialize, PartialEq, Eq)]
+pub struct SupportedCollationSet(
+    #[xml(
+        ns = "rustical_dav::namespace::NS_CALDAV",
+        flatten,
+        rename = "supported-collation"
+    )]
+    pub Vec<SupportedCollation>,
+);
+
+impl Default for SupportedCollationSet {
+    fn default() -> Self {
+        Self(vec![
+            SupportedCollation(TextCollation::AsciiCasemap),
+            SupportedCollation(TextCollation::Octet),
+        ])
+    }
+}
+
 #[derive(Debug, Clone, XmlSerialize, PartialEq, Eq)]
 pub struct CalendarData {
     #[xml(ty = "attr")]

crates/caldav/src/calendar/resource.rs

@@ -1,6 +1,6 @@
 use super::prop::{SupportedCalendarComponentSet, SupportedCalendarData};
 use crate::Error;
-use crate::calendar::prop::ReportMethod;
+use crate::calendar::prop::{ReportMethod, SupportedCollationSet};
 use chrono::{DateTime, Utc};
 use derive_more::derive::{From, Into};
 use ical::IcalParser;
@@ -39,6 +39,8 @@ pub enum CalendarProp {
     SupportedCalendarComponentSet(SupportedCalendarComponentSet),
     #[xml(ns = "rustical_dav::namespace::NS_CALDAV", skip_deserializing)]
     SupportedCalendarData(SupportedCalendarData),
+    #[xml(ns = "rustical_dav::namespace::NS_CALDAV", skip_deserializing)]
+    SupportedCollationSet(SupportedCollationSet),
     #[xml(ns = "rustical_dav::namespace::NS_DAV")]
     MaxResourceSize(i64),
     #[xml(skip_deserializing)]
@@ -156,6 +158,9 @@ impl Resource for CalendarResource {
                 CalendarPropName::SupportedCalendarData => {
                     CalendarProp::SupportedCalendarData(SupportedCalendarData::default())
                 }
+                CalendarPropName::SupportedCollationSet => {
+                    CalendarProp::SupportedCollationSet(SupportedCollationSet::default())
+                }
                 CalendarPropName::MaxResourceSize => CalendarProp::MaxResourceSize(10_000_000),
                 CalendarPropName::SupportedReportSet => {
                     CalendarProp::SupportedReportSet(SupportedReportSet::all())
@@ -183,9 +188,6 @@ impl Resource for CalendarResource {
     }
 
     fn set_prop(&mut self, prop: Self::Prop) -> Result<(), rustical_dav::Error> {
-        if self.read_only {
-            return Err(rustical_dav::Error::PropReadOnly);
-        }
         match prop {
             CalendarPropWrapper::Calendar(prop) => match prop {
                 CalendarProp::CalendarColor(color) => {
@@ -244,6 +246,7 @@ impl Resource for CalendarResource {
                 }
                 CalendarProp::TimezoneServiceSet(_)
                 | CalendarProp::SupportedCalendarData(_)
+                | CalendarProp::SupportedCollationSet(_)
                 | CalendarProp::MaxResourceSize(_)
                 | CalendarProp::SupportedReportSet(_)
                 | CalendarProp::Source(_)
@@ -257,9 +260,6 @@ impl Resource for CalendarResource {
     }
 
     fn remove_prop(&mut self, prop: &CalendarPropWrapperName) -> Result<(), rustical_dav::Error> {
-        if self.read_only {
-            return Err(rustical_dav::Error::PropReadOnly);
-        }
         match prop {
             CalendarPropWrapperName::Calendar(prop) => match prop {
                 CalendarPropName::CalendarColor => {
@@ -283,6 +283,7 @@ impl Resource for CalendarResource {
                 }
                 CalendarPropName::TimezoneServiceSet
                 | CalendarPropName::SupportedCalendarData
+                | CalendarPropName::SupportedCollationSet
                 | CalendarPropName::MaxResourceSize
                 | CalendarPropName::SupportedReportSet
                 | CalendarPropName::Source
@@ -310,16 +311,11 @@ impl Resource for CalendarResource {
     }
 
     fn get_user_privileges(&self, user: &Principal) -> Result<UserPrivilegeSet, Self::Error> {
-        if self.cal.subscription_url.is_some() {
+        if self.cal.subscription_url.is_some() || self.read_only {
             return Ok(UserPrivilegeSet::owner_write_properties(
                 user.is_principal(&self.cal.principal),
             ));
         }
-        if self.read_only {
-            return Ok(UserPrivilegeSet::owner_read(
-                user.is_principal(&self.cal.principal),
-            ));
-        }
 
         Ok(UserPrivilegeSet::owner_only(
             user.is_principal(&self.cal.principal),

crates/caldav/src/calendar/test_files/propfind.outputs

@@ -11,6 +11,7 @@
             <calendar-order xmlns="http://apple.com/ns/ical/"/>
             <supported-calendar-component-set xmlns="urn:ietf:params:xml:ns:caldav"/>
             <supported-calendar-data xmlns="urn:ietf:params:xml:ns:caldav"/>
+            <supported-collation-set xmlns="urn:ietf:params:xml:ns:caldav"/>
             <max-resource-size xmlns="DAV:"/>
             <supported-report-set xmlns="DAV:"/>
             <source xmlns="http://calendarserver.org/ns/"/>
@@ -160,6 +161,10 @@ END:VCALENDAR
             <CAL:supported-calendar-data>
                 <CAL:calendar-data content-type="text/calendar" version="2.0"/>
             </CAL:supported-calendar-data>
+            <CAL:supported-collation-set>
+                <CAL:supported-collation>i;ascii-casemap</CAL:supported-collation>
+                <CAL:supported-collation>i;octet</CAL:supported-collation>
+            </CAL:supported-collation-set>
             <max-resource-size>10000000</max-resource-size>
             <supported-report-set>
                 <supported-report>
@@ -206,6 +211,9 @@ END:VCALENDAR
                 <privilege>
                     <read/>
                 </privilege>
+                <privilege>
+                    <write-properties/>
+                </privilege>
                 <privilege>
                     <read-acl/>
                 </privilege>

crates/caldav/src/calendar/tests.rs

@@ -39,9 +39,7 @@ async fn test_propfind() {
                 .unwrap()
                 .trim()
                 .replace("\r\n", "\n");
-            println!("{output}");
+            similar_asserts::assert_eq!(expected_output, output);
-            println!("{}, {} \n\n\n", output.len(), expected_output.len());
-            assert_eq!(output, expected_output);
         }
     }
 }

crates/caldav/src/calendar_object/methods.rs

@@ -11,7 +11,7 @@ use rustical_ical::CalendarObject;
 use rustical_store::CalendarStore;
 use rustical_store::auth::Principal;
 use std::str::FromStr;
-use tracing::{debug, error, instrument};
+use tracing::{debug, instrument};
 
 #[instrument(skip(cal_store))]
 pub async fn get_event<C: CalendarStore>(
@@ -78,18 +78,10 @@ pub async fn put_event<C: CalendarStore>(
         true
     };
 
-    let Ok(object) = CalendarObject::from_ics(body.clone()) else {
+    let Ok(object) = CalendarObject::from_ics(body.clone(), Some(object_id)) else {
         debug!("invalid calendar data:\n{body}");
         return Err(Error::PreconditionFailed(Precondition::ValidCalendarData));
     };
-    if object.get_id() != object_id {
-        error!(
-            "Calendar object UID and file name not matching: UID={}, filename={}",
-            object.get_id(),
-            object_id
-        );
-        return Err(Error::PreconditionFailed(Precondition::MatchingUid));
-    }
     cal_store
         .put_object(principal, calendar_id, object, overwrite)
         .await?;

crates/caldav/src/error.rs

@@ -12,8 +12,6 @@ pub enum Precondition {
     #[error("valid-calendar-data")]
     #[xml(ns = "rustical_dav::namespace::NS_CALDAV")]
     ValidCalendarData,
-    #[error("matching-uid")]
-    MatchingUid,
 }
 
 impl IntoResponse for Precondition {

crates/carddav/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "rustical_carddav"
 version.workspace = true
+rust-version.workspace = true
 edition.workspace = true
 description.workspace = true
 repository.workspace = true
@@ -11,19 +12,19 @@ publish = false
 axum.workspace = true
 axum-extra.workspace = true
 tower.workspace = true
-async-trait = { workspace = true }
+async-trait.workspace = true
-thiserror = { workspace = true }
+thiserror.workspace = true
-quick-xml = { workspace = true }
+quick-xml.workspace = true
-tracing = { workspace = true }
+tracing.workspace = true
-futures-util = { workspace = true }
+futures-util.workspace = true
-derive_more = { workspace = true }
+derive_more.workspace = true
-base64 = { workspace = true }
+base64.workspace = true
-serde = { workspace = true }
+serde.workspace = true
-tokio = { workspace = true }
+tokio.workspace = true
-url = { workspace = true }
+url.workspace = true
-rustical_dav = { workspace = true }
+rustical_dav.workspace = true
-rustical_store = { workspace = true }
+rustical_store.workspace = true
-chrono = { workspace = true }
+chrono.workspace = true
 rustical_xml.workspace = true
 uuid.workspace = true
 rustical_dav_push.workspace = true

crates/carddav/src/addressbook/methods/report/addressbook_multiget.rs

@@ -34,7 +34,9 @@ pub async fn get_objects_addressbook_multiget<AS: AddressbookStore>(
     let mut not_found = vec![];
 
     for href in &addressbook_multiget.href {
-        if let Some(filename) = href.strip_prefix(path) {
+        if let Ok(href) = percent_encoding::percent_decode_str(href).decode_utf8()
+            && let Some(filename) = href.strip_prefix(path)
+        {
             let filename = filename.trim_start_matches('/');
             if let Some(object_id) = filename.strip_suffix(".vcf") {
                 match store
@@ -42,11 +44,11 @@ pub async fn get_objects_addressbook_multiget<AS: AddressbookStore>(
                     .await
                 {
                     Ok(object) => result.push(object),
-                    Err(rustical_store::Error::NotFound) => not_found.push(href.to_owned()),
+                    Err(rustical_store::Error::NotFound) => not_found.push(href.to_string()),
                     Err(err) => return Err(err.into()),
                 }
             } else {
-                not_found.push(href.to_owned());
+                not_found.push(href.to_string());
             }
         } else {
             not_found.push(href.to_owned());

crates/dav/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "rustical_dav"
 version.workspace = true
+rust-version.workspace = true
 edition.workspace = true
 description.workspace = true
 repository.workspace = true
@@ -11,7 +12,6 @@ publish = false
 axum.workspace = true
 tower.workspace = true
 axum-extra.workspace = true
-
 rustical_xml.workspace = true
 async-trait.workspace = true
 futures-util.workspace = true

crates/dav/src/resource/methods/proppatch.rs

@@ -88,7 +88,7 @@ pub async fn route_proppatch<R: ResourceService>(
         .get_resource(path_components, false)
         .await?;
     let privileges = resource.get_user_privileges(principal)?;
-    if !privileges.has(&UserPrivilege::Write) {
+    if !privileges.has(&UserPrivilege::WriteProperties) {
         return Err(Error::Unauthorized.into());
     }
 

crates/dav_push/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "rustical_dav_push"
 version.workspace = true
+rust-version.workspace = true
 edition.workspace = true
 description.workspace = true
 repository.workspace = true
@@ -9,15 +10,15 @@ publish = false
 
 [dependencies]
 rustical_xml.workspace = true
-async-trait = { workspace = true }
+async-trait.workspace = true
-futures-util = { workspace = true }
+futures-util.workspace = true
-quick-xml = { workspace = true }
+quick-xml.workspace = true
-serde = { workspace = true }
+serde.workspace = true
-thiserror = { workspace = true }
+thiserror.workspace = true
-itertools = { workspace = true }
+itertools.workspace = true
-log = { workspace = true }
+log.workspace = true
-derive_more = { workspace = true }
+derive_more.workspace = true
-tracing = { workspace = true }
+tracing.workspace = true
 reqwest.workspace = true
 tokio.workspace = true
 rustical_dav.workspace = true

crates/dav_push/src/lib.rs

@@ -59,7 +59,7 @@ impl<S: SubscriptionStore> DavPushController<S> {
             let mut latest_messages = HashMap::new();
             for message in messages {
                 if matches!(message.data, CollectionOperationInfo::Content { .. }) {
-                    latest_messages.insert(message.topic.to_string(), message);
+                    latest_messages.insert(message.topic.clone(), message);
                 }
             }
             let messages = latest_messages.into_values();
@@ -156,12 +156,13 @@ impl<S: SubscriptionStore> DavPushController<S> {
     ) -> Result<(), NotifierError> {
         if subsciption.public_key_type != "p256dh" {
             return Err(NotifierError::InvalidPublicKeyType(
-                subsciption.public_key_type.to_string(),
+                subsciption.public_key_type.clone(),
             ));
         }
-        let endpoint = subsciption.push_resource.parse().map_err(|_| {
+        let endpoint = subsciption
-            NotifierError::InvalidEndpointUrl(subsciption.push_resource.to_string())
+            .push_resource
-        })?;
+            .parse()
+            .map_err(|_| NotifierError::InvalidEndpointUrl(subsciption.push_resource.clone()))?;
         let ua_public = base64::engine::general_purpose::URL_SAFE_NO_PAD
             .decode(&subsciption.public_key)
             .map_err(|_| NotifierError::InvalidKeyEncoding)?;

crates/frontend/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "rustical_frontend"
 version.workspace = true
+rust-version.workspace = true
 edition.workspace = true
 description.workspace = true
 repository.workspace = true
@@ -39,3 +40,6 @@ headers.workspace = true
 tower-sessions.workspace = true
 percent-encoding.workspace = true
 tower-http = { workspace = true, optional = true }
+vtimezones-rs.workspace = true
+serde_json.workspace = true
+itertools.workspace = true

crates/frontend/js-components/deno.json

@@ -13,6 +13,6 @@
   "imports": {
     "@deno/vite-plugin": "npm:@deno/vite-plugin@^1.0.5",
     "lit": "npm:lit@^3.3.1",
-    "vite": "npm:vite@^7.1.7"
+    "vite": "npm:vite@^7.1.12"
   }
 }

crates/frontend/js-components/deno.lock

@@ -1,145 +1,145 @@
 {
   "version": "5",
   "specifiers": {
-    "npm:@deno/vite-plugin@^1.0.5": "1.0.5_vite@7.1.7__picomatch@4.0.3",
+    "npm:@deno/vite-plugin@^1.0.5": "1.0.5_vite@7.1.12__picomatch@4.0.3",
     "npm:lit@^3.3.1": "3.3.1",
-    "npm:vite@*": "7.1.7_picomatch@4.0.3",
+    "npm:vite@*": "7.1.12_picomatch@4.0.3",
-    "npm:vite@^7.1.7": "7.1.7_picomatch@4.0.3"
+    "npm:vite@^7.1.12": "7.1.12_picomatch@4.0.3"
   },
   "npm": {
-    "@deno/vite-plugin@1.0.5_vite@7.1.7__picomatch@4.0.3": {
+    "@deno/vite-plugin@1.0.5_vite@7.1.12__picomatch@4.0.3": {
       "integrity": "sha512-tLja5n4dyMhcze1NzvSs2iiriBymfBlDCZIrjMTxb9O2ru0gvmV6mn5oBD2teNw5Sd92cj3YJzKwsAs8tMJXlg==",
       "dependencies": [
         "vite"
       ]
     },
-    "@esbuild/aix-ppc64@0.25.10": {
+    "@esbuild/aix-ppc64@0.25.12": {
-      "integrity": "sha512-0NFWnA+7l41irNuaSVlLfgNT12caWJVLzp5eAVhZ0z1qpxbockccEt3s+149rE64VUI3Ml2zt8Nv5JVc4QXTsw==",
+      "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==",
       "os": ["aix"],
       "cpu": ["ppc64"]
     },
-    "@esbuild/android-arm64@0.25.10": {
+    "@esbuild/android-arm64@0.25.12": {
-      "integrity": "sha512-LSQa7eDahypv/VO6WKohZGPSJDq5OVOo3UoFR1E4t4Gj1W7zEQMUhI+lo81H+DtB+kP+tDgBp+M4oNCwp6kffg==",
+      "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==",
       "os": ["android"],
       "cpu": ["arm64"]
     },
-    "@esbuild/android-arm@0.25.10": {
+    "@esbuild/android-arm@0.25.12": {
-      "integrity": "sha512-dQAxF1dW1C3zpeCDc5KqIYuZ1tgAdRXNoZP7vkBIRtKZPYe2xVr/d3SkirklCHudW1B45tGiUlz2pUWDfbDD4w==",
+      "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==",
       "os": ["android"],
       "cpu": ["arm"]
     },
-    "@esbuild/android-x64@0.25.10": {
+    "@esbuild/android-x64@0.25.12": {
-      "integrity": "sha512-MiC9CWdPrfhibcXwr39p9ha1x0lZJ9KaVfvzA0Wxwz9ETX4v5CHfF09bx935nHlhi+MxhA63dKRRQLiVgSUtEg==",
+      "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==",
       "os": ["android"],
       "cpu": ["x64"]
     },
-    "@esbuild/darwin-arm64@0.25.10": {
+    "@esbuild/darwin-arm64@0.25.12": {
-      "integrity": "sha512-JC74bdXcQEpW9KkV326WpZZjLguSZ3DfS8wrrvPMHgQOIEIG/sPXEN/V8IssoJhbefLRcRqw6RQH2NnpdprtMA==",
+      "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==",
       "os": ["darwin"],
       "cpu": ["arm64"]
     },
-    "@esbuild/darwin-x64@0.25.10": {
+    "@esbuild/darwin-x64@0.25.12": {
-      "integrity": "sha512-tguWg1olF6DGqzws97pKZ8G2L7Ig1vjDmGTwcTuYHbuU6TTjJe5FXbgs5C1BBzHbJ2bo1m3WkQDbWO2PvamRcg==",
+      "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==",
       "os": ["darwin"],
       "cpu": ["x64"]
     },
-    "@esbuild/freebsd-arm64@0.25.10": {
+    "@esbuild/freebsd-arm64@0.25.12": {
-      "integrity": "sha512-3ZioSQSg1HT2N05YxeJWYR+Libe3bREVSdWhEEgExWaDtyFbbXWb49QgPvFH8u03vUPX10JhJPcz7s9t9+boWg==",
+      "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==",
       "os": ["freebsd"],
       "cpu": ["arm64"]
     },
-    "@esbuild/freebsd-x64@0.25.10": {
+    "@esbuild/freebsd-x64@0.25.12": {
-      "integrity": "sha512-LLgJfHJk014Aa4anGDbh8bmI5Lk+QidDmGzuC2D+vP7mv/GeSN+H39zOf7pN5N8p059FcOfs2bVlrRr4SK9WxA==",
+      "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==",
       "os": ["freebsd"],
       "cpu": ["x64"]
     },
-    "@esbuild/linux-arm64@0.25.10": {
+    "@esbuild/linux-arm64@0.25.12": {
-      "integrity": "sha512-5luJWN6YKBsawd5f9i4+c+geYiVEw20FVW5x0v1kEMWNq8UctFjDiMATBxLvmmHA4bf7F6hTRaJgtghFr9iziQ==",
+      "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==",
       "os": ["linux"],
       "cpu": ["arm64"]
     },
-    "@esbuild/linux-arm@0.25.10": {
+    "@esbuild/linux-arm@0.25.12": {
-      "integrity": "sha512-oR31GtBTFYCqEBALI9r6WxoU/ZofZl962pouZRTEYECvNF/dtXKku8YXcJkhgK/beU+zedXfIzHijSRapJY3vg==",
+      "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==",
       "os": ["linux"],
       "cpu": ["arm"]
     },
-    "@esbuild/linux-ia32@0.25.10": {
+    "@esbuild/linux-ia32@0.25.12": {
-      "integrity": "sha512-NrSCx2Kim3EnnWgS4Txn0QGt0Xipoumb6z6sUtl5bOEZIVKhzfyp/Lyw4C1DIYvzeW/5mWYPBFJU3a/8Yr75DQ==",
+      "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==",
       "os": ["linux"],
       "cpu": ["ia32"]
     },
-    "@esbuild/linux-loong64@0.25.10": {
+    "@esbuild/linux-loong64@0.25.12": {
-      "integrity": "sha512-xoSphrd4AZda8+rUDDfD9J6FUMjrkTz8itpTITM4/xgerAZZcFW7Dv+sun7333IfKxGG8gAq+3NbfEMJfiY+Eg==",
+      "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==",
       "os": ["linux"],
       "cpu": ["loong64"]
     },
-    "@esbuild/linux-mips64el@0.25.10": {
+    "@esbuild/linux-mips64el@0.25.12": {
-      "integrity": "sha512-ab6eiuCwoMmYDyTnyptoKkVS3k8fy/1Uvq7Dj5czXI6DF2GqD2ToInBI0SHOp5/X1BdZ26RKc5+qjQNGRBelRA==",
+      "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==",
       "os": ["linux"],
       "cpu": ["mips64el"]
     },
-    "@esbuild/linux-ppc64@0.25.10": {
+    "@esbuild/linux-ppc64@0.25.12": {
-      "integrity": "sha512-NLinzzOgZQsGpsTkEbdJTCanwA5/wozN9dSgEl12haXJBzMTpssebuXR42bthOF3z7zXFWH1AmvWunUCkBE4EA==",
+      "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==",
       "os": ["linux"],
       "cpu": ["ppc64"]
     },
-    "@esbuild/linux-riscv64@0.25.10": {
+    "@esbuild/linux-riscv64@0.25.12": {
-      "integrity": "sha512-FE557XdZDrtX8NMIeA8LBJX3dC2M8VGXwfrQWU7LB5SLOajfJIxmSdyL/gU1m64Zs9CBKvm4UAuBp5aJ8OgnrA==",
+      "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==",
       "os": ["linux"],
       "cpu": ["riscv64"]
     },
-    "@esbuild/linux-s390x@0.25.10": {
+    "@esbuild/linux-s390x@0.25.12": {
-      "integrity": "sha512-3BBSbgzuB9ajLoVZk0mGu+EHlBwkusRmeNYdqmznmMc9zGASFjSsxgkNsqmXugpPk00gJ0JNKh/97nxmjctdew==",
+      "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==",
       "os": ["linux"],
       "cpu": ["s390x"]
     },
-    "@esbuild/linux-x64@0.25.10": {
+    "@esbuild/linux-x64@0.25.12": {
-      "integrity": "sha512-QSX81KhFoZGwenVyPoberggdW1nrQZSvfVDAIUXr3WqLRZGZqWk/P4T8p2SP+de2Sr5HPcvjhcJzEiulKgnxtA==",
+      "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==",
       "os": ["linux"],
       "cpu": ["x64"]
     },
-    "@esbuild/netbsd-arm64@0.25.10": {
+    "@esbuild/netbsd-arm64@0.25.12": {
-      "integrity": "sha512-AKQM3gfYfSW8XRk8DdMCzaLUFB15dTrZfnX8WXQoOUpUBQ+NaAFCP1kPS/ykbbGYz7rxn0WS48/81l9hFl3u4A==",
+      "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==",
       "os": ["netbsd"],
       "cpu": ["arm64"]
     },
-    "@esbuild/netbsd-x64@0.25.10": {
+    "@esbuild/netbsd-x64@0.25.12": {
-      "integrity": "sha512-7RTytDPGU6fek/hWuN9qQpeGPBZFfB4zZgcz2VK2Z5VpdUxEI8JKYsg3JfO0n/Z1E/6l05n0unDCNc4HnhQGig==",
+      "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==",
       "os": ["netbsd"],
       "cpu": ["x64"]
     },
-    "@esbuild/openbsd-arm64@0.25.10": {
+    "@esbuild/openbsd-arm64@0.25.12": {
-      "integrity": "sha512-5Se0VM9Wtq797YFn+dLimf2Zx6McttsH2olUBsDml+lm0GOCRVebRWUvDtkY4BWYv/3NgzS8b/UM3jQNh5hYyw==",
+      "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==",
       "os": ["openbsd"],
       "cpu": ["arm64"]
     },
-    "@esbuild/openbsd-x64@0.25.10": {
+    "@esbuild/openbsd-x64@0.25.12": {
-      "integrity": "sha512-XkA4frq1TLj4bEMB+2HnI0+4RnjbuGZfet2gs/LNs5Hc7D89ZQBHQ0gL2ND6Lzu1+QVkjp3x1gIcPKzRNP8bXw==",
+      "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==",
       "os": ["openbsd"],
       "cpu": ["x64"]
     },
-    "@esbuild/openharmony-arm64@0.25.10": {
+    "@esbuild/openharmony-arm64@0.25.12": {
-      "integrity": "sha512-AVTSBhTX8Y/Fz6OmIVBip9tJzZEUcY8WLh7I59+upa5/GPhh2/aM6bvOMQySspnCCHvFi79kMtdJS1w0DXAeag==",
+      "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==",
       "os": ["openharmony"],
       "cpu": ["arm64"]
     },
-    "@esbuild/sunos-x64@0.25.10": {
+    "@esbuild/sunos-x64@0.25.12": {
-      "integrity": "sha512-fswk3XT0Uf2pGJmOpDB7yknqhVkJQkAQOcW/ccVOtfx05LkbWOaRAtn5SaqXypeKQra1QaEa841PgrSL9ubSPQ==",
+      "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==",
       "os": ["sunos"],
       "cpu": ["x64"]
     },
-    "@esbuild/win32-arm64@0.25.10": {
+    "@esbuild/win32-arm64@0.25.12": {
-      "integrity": "sha512-ah+9b59KDTSfpaCg6VdJoOQvKjI33nTaQr4UluQwW7aEwZQsbMCfTmfEO4VyewOxx4RaDT/xCy9ra2GPWmO7Kw==",
+      "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==",
       "os": ["win32"],
       "cpu": ["arm64"]
     },
-    "@esbuild/win32-ia32@0.25.10": {
+    "@esbuild/win32-ia32@0.25.12": {
-      "integrity": "sha512-QHPDbKkrGO8/cz9LKVnJU22HOi4pxZnZhhA2HYHez5Pz4JeffhDjf85E57Oyco163GnzNCVkZK0b/n4Y0UHcSw==",
+      "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==",
       "os": ["win32"],
       "cpu": ["ia32"]
     },
-    "@esbuild/win32-x64@0.25.10": {
+    "@esbuild/win32-x64@0.25.12": {
-      "integrity": "sha512-9KpxSVFCu0iK1owoez6aC/s/EdUQLDN3adTxGCqxMVhrPDj6bt5dbrHDXUuq+Bs2vATFBBrQS5vdQ/Ed2P+nbw==",
+      "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==",
       "os": ["win32"],
       "cpu": ["x64"]
     },
@@ -152,113 +152,113 @@
         "@lit-labs/ssr-dom-shim"
       ]
     },
-    "@rollup/rollup-android-arm-eabi@4.52.2": {
+    "@rollup/rollup-android-arm-eabi@4.52.5": {
-      "integrity": "sha512-o3pcKzJgSGt4d74lSZ+OCnHwkKBeAbFDmbEm5gg70eA8VkyCuC/zV9TwBnmw6VjDlRdF4Pshfb+WE9E6XY1PoQ==",
+      "integrity": "sha512-8c1vW4ocv3UOMp9K+gToY5zL2XiiVw3k7f1ksf4yO1FlDFQ1C2u72iACFnSOceJFsWskc2WZNqeRhFRPzv+wtQ==",
       "os": ["android"],
       "cpu": ["arm"]
     },
-    "@rollup/rollup-android-arm64@4.52.2": {
+    "@rollup/rollup-android-arm64@4.52.5": {
-      "integrity": "sha512-cqFSWO5tX2vhC9hJTK8WAiPIm4Q8q/cU8j2HQA0L3E1uXvBYbOZMhE2oFL8n2pKB5sOCHY6bBuHaRwG7TkfJyw==",
+      "integrity": "sha512-mQGfsIEFcu21mvqkEKKu2dYmtuSZOBMmAl5CFlPGLY94Vlcm+zWApK7F/eocsNzp8tKmbeBP8yXyAbx0XHsFNA==",
       "os": ["android"],
       "cpu": ["arm64"]
     },
-    "@rollup/rollup-darwin-arm64@4.52.2": {
+    "@rollup/rollup-darwin-arm64@4.52.5": {
-      "integrity": "sha512-vngduywkkv8Fkh3wIZf5nFPXzWsNsVu1kvtLETWxTFf/5opZmflgVSeLgdHR56RQh71xhPhWoOkEBvbehwTlVA==",
+      "integrity": "sha512-takF3CR71mCAGA+v794QUZ0b6ZSrgJkArC+gUiG6LB6TQty9T0Mqh3m2ImRBOxS2IeYBo4lKWIieSvnEk2OQWA==",
       "os": ["darwin"],
       "cpu": ["arm64"]
     },
-    "@rollup/rollup-darwin-x64@4.52.2": {
+    "@rollup/rollup-darwin-x64@4.52.5": {
-      "integrity": "sha512-h11KikYrUCYTrDj6h939hhMNlqU2fo/X4NB0OZcys3fya49o1hmFaczAiJWVAFgrM1NCP6RrO7lQKeVYSKBPSQ==",
+      "integrity": "sha512-W901Pla8Ya95WpxDn//VF9K9u2JbocwV/v75TE0YIHNTbhqUTv9w4VuQ9MaWlNOkkEfFwkdNhXgcLqPSmHy0fA==",
       "os": ["darwin"],
       "cpu": ["x64"]
     },
-    "@rollup/rollup-freebsd-arm64@4.52.2": {
+    "@rollup/rollup-freebsd-arm64@4.52.5": {
-      "integrity": "sha512-/eg4CI61ZUkLXxMHyVlmlGrSQZ34xqWlZNW43IAU4RmdzWEx0mQJ2mN/Cx4IHLVZFL6UBGAh+/GXhgvGb+nVxw==",
+      "integrity": "sha512-QofO7i7JycsYOWxe0GFqhLmF6l1TqBswJMvICnRUjqCx8b47MTo46W8AoeQwiokAx3zVryVnxtBMcGcnX12LvA==",
       "os": ["freebsd"],
       "cpu": ["arm64"]
     },
-    "@rollup/rollup-freebsd-x64@4.52.2": {
+    "@rollup/rollup-freebsd-x64@4.52.5": {
-      "integrity": "sha512-QOWgFH5X9+p+S1NAfOqc0z8qEpJIoUHf7OWjNUGOeW18Mx22lAUOiA9b6r2/vpzLdfxi/f+VWsYjUOMCcYh0Ng==",
+      "integrity": "sha512-jr21b/99ew8ujZubPo9skbrItHEIE50WdV86cdSoRkKtmWa+DDr6fu2c/xyRT0F/WazZpam6kk7IHBerSL7LDQ==",
       "os": ["freebsd"],
       "cpu": ["x64"]
     },
-    "@rollup/rollup-linux-arm-gnueabihf@4.52.2": {
+    "@rollup/rollup-linux-arm-gnueabihf@4.52.5": {
-      "integrity": "sha512-kDWSPafToDd8LcBYd1t5jw7bD5Ojcu12S3uT372e5HKPzQt532vW+rGFFOaiR0opxePyUkHrwz8iWYEyH1IIQA==",
+      "integrity": "sha512-PsNAbcyv9CcecAUagQefwX8fQn9LQ4nZkpDboBOttmyffnInRy8R8dSg6hxxl2Re5QhHBf6FYIDhIj5v982ATQ==",
       "os": ["linux"],
       "cpu": ["arm"]
     },
-    "@rollup/rollup-linux-arm-musleabihf@4.52.2": {
+    "@rollup/rollup-linux-arm-musleabihf@4.52.5": {
-      "integrity": "sha512-gKm7Mk9wCv6/rkzwCiUC4KnevYhlf8ztBrDRT9g/u//1fZLapSRc+eDZj2Eu2wpJ+0RzUKgtNijnVIB4ZxyL+w==",
+      "integrity": "sha512-Fw4tysRutyQc/wwkmcyoqFtJhh0u31K+Q6jYjeicsGJJ7bbEq8LwPWV/w0cnzOqR2m694/Af6hpFayLJZkG2VQ==",
       "os": ["linux"],
       "cpu": ["arm"]
     },
-    "@rollup/rollup-linux-arm64-gnu@4.52.2": {
+    "@rollup/rollup-linux-arm64-gnu@4.52.5": {
-      "integrity": "sha512-66lA8vnj5mB/rtDNwPgrrKUOtCLVQypkyDa2gMfOefXK6rcZAxKLO9Fy3GkW8VkPnENv9hBkNOFfGLf6rNKGUg==",
+      "integrity": "sha512-a+3wVnAYdQClOTlyapKmyI6BLPAFYs0JM8HRpgYZQO02rMR09ZcV9LbQB+NL6sljzG38869YqThrRnfPMCDtZg==",
       "os": ["linux"],
       "cpu": ["arm64"]
     },
-    "@rollup/rollup-linux-arm64-musl@4.52.2": {
+    "@rollup/rollup-linux-arm64-musl@4.52.5": {
-      "integrity": "sha512-s+OPucLNdJHvuZHuIz2WwncJ+SfWHFEmlC5nKMUgAelUeBUnlB4wt7rXWiyG4Zn07uY2Dd+SGyVa9oyLkVGOjA==",
+      "integrity": "sha512-AvttBOMwO9Pcuuf7m9PkC1PUIKsfaAJ4AYhy944qeTJgQOqJYJ9oVl2nYgY7Rk0mkbsuOpCAYSs6wLYB2Xiw0Q==",
       "os": ["linux"],
       "cpu": ["arm64"]
     },
-    "@rollup/rollup-linux-loong64-gnu@4.52.2": {
+    "@rollup/rollup-linux-loong64-gnu@4.52.5": {
-      "integrity": "sha512-8wTRM3+gVMDLLDdaT6tKmOE3lJyRy9NpJUS/ZRWmLCmOPIJhVyXwjBo+XbrrwtV33Em1/eCTd5TuGJm4+DmYjw==",
+      "integrity": "sha512-DkDk8pmXQV2wVrF6oq5tONK6UHLz/XcEVow4JTTerdeV1uqPeHxwcg7aFsfnSm9L+OO8WJsWotKM2JJPMWrQtA==",
       "os": ["linux"],
       "cpu": ["loong64"]
     },
-    "@rollup/rollup-linux-ppc64-gnu@4.52.2": {
+    "@rollup/rollup-linux-ppc64-gnu@4.52.5": {
-      "integrity": "sha512-6yqEfgJ1anIeuP2P/zhtfBlDpXUb80t8DpbYwXQ3bQd95JMvUaqiX+fKqYqUwZXqdJDd8xdilNtsHM2N0cFm6A==",
+      "integrity": "sha512-W/b9ZN/U9+hPQVvlGwjzi+Wy4xdoH2I8EjaCkMvzpI7wJUs8sWJ03Rq96jRnHkSrcHTpQe8h5Tg3ZzUPGauvAw==",
       "os": ["linux"],
       "cpu": ["ppc64"]
     },
-    "@rollup/rollup-linux-riscv64-gnu@4.52.2": {
+    "@rollup/rollup-linux-riscv64-gnu@4.52.5": {
-      "integrity": "sha512-sshYUiYVSEI2B6dp4jMncwxbrUqRdNApF2c3bhtLAU0qA8Lrri0p0NauOsTWh3yCCCDyBOjESHMExonp7Nzc0w==",
+      "integrity": "sha512-sjQLr9BW7R/ZiXnQiWPkErNfLMkkWIoCz7YMn27HldKsADEKa5WYdobaa1hmN6slu9oWQbB6/jFpJ+P2IkVrmw==",
       "os": ["linux"],
       "cpu": ["riscv64"]
     },
-    "@rollup/rollup-linux-riscv64-musl@4.52.2": {
+    "@rollup/rollup-linux-riscv64-musl@4.52.5": {
-      "integrity": "sha512-duBLgd+3pqC4MMwBrKkFxaZerUxZcYApQVC5SdbF5/e/589GwVvlRUnyqMFbM8iUSb1BaoX/3fRL7hB9m2Pj8Q==",
+      "integrity": "sha512-hq3jU/kGyjXWTvAh2awn8oHroCbrPm8JqM7RUpKjalIRWWXE01CQOf/tUNWNHjmbMHg/hmNCwc/Pz3k1T/j/Lg==",
       "os": ["linux"],
       "cpu": ["riscv64"]
     },
-    "@rollup/rollup-linux-s390x-gnu@4.52.2": {
+    "@rollup/rollup-linux-s390x-gnu@4.52.5": {
-      "integrity": "sha512-tzhYJJidDUVGMgVyE+PmxENPHlvvqm1KILjjZhB8/xHYqAGeizh3GBGf9u6WdJpZrz1aCpIIHG0LgJgH9rVjHQ==",
+      "integrity": "sha512-gn8kHOrku8D4NGHMK1Y7NA7INQTRdVOntt1OCYypZPRt6skGbddska44K8iocdpxHTMMNui5oH4elPH4QOLrFQ==",
       "os": ["linux"],
       "cpu": ["s390x"]
     },
-    "@rollup/rollup-linux-x64-gnu@4.52.2": {
+    "@rollup/rollup-linux-x64-gnu@4.52.5": {
-      "integrity": "sha512-opH8GSUuVcCSSyHHcl5hELrmnk4waZoVpgn/4FDao9iyE4WpQhyWJ5ryl5M3ocp4qkRuHfyXnGqg8M9oKCEKRA==",
+      "integrity": "sha512-hXGLYpdhiNElzN770+H2nlx+jRog8TyynpTVzdlc6bndktjKWyZyiCsuDAlpd+j+W+WNqfcyAWz9HxxIGfZm1Q==",
       "os": ["linux"],
       "cpu": ["x64"]
     },
-    "@rollup/rollup-linux-x64-musl@4.52.2": {
+    "@rollup/rollup-linux-x64-musl@4.52.5": {
-      "integrity": "sha512-LSeBHnGli1pPKVJ79ZVJgeZWWZXkEe/5o8kcn23M8eMKCUANejchJbF/JqzM4RRjOJfNRhKJk8FuqL1GKjF5oQ==",
+      "integrity": "sha512-arCGIcuNKjBoKAXD+y7XomR9gY6Mw7HnFBv5Rw7wQRvwYLR7gBAgV7Mb2QTyjXfTveBNFAtPt46/36vV9STLNg==",
       "os": ["linux"],
       "cpu": ["x64"]
     },
-    "@rollup/rollup-openharmony-arm64@4.52.2": {
+    "@rollup/rollup-openharmony-arm64@4.52.5": {
-      "integrity": "sha512-uPj7MQ6/s+/GOpolavm6BPo+6CbhbKYyZHUDvZ/SmJM7pfDBgdGisFX3bY/CBDMg2ZO4utfhlApkSfZ92yXw7Q==",
+      "integrity": "sha512-QoFqB6+/9Rly/RiPjaomPLmR/13cgkIGfA40LHly9zcH1S0bN2HVFYk3a1eAyHQyjs3ZJYlXvIGtcCs5tko9Cw==",
       "os": ["openharmony"],
       "cpu": ["arm64"]
     },
-    "@rollup/rollup-win32-arm64-msvc@4.52.2": {
+    "@rollup/rollup-win32-arm64-msvc@4.52.5": {
-      "integrity": "sha512-Z9MUCrSgIaUeeHAiNkm3cQyst2UhzjPraR3gYYfOjAuZI7tcFRTOD+4cHLPoS/3qinchth+V56vtqz1Tv+6KPA==",
+      "integrity": "sha512-w0cDWVR6MlTstla1cIfOGyl8+qb93FlAVutcor14Gf5Md5ap5ySfQ7R9S/NjNaMLSFdUnKGEasmVnu3lCMqB7w==",
       "os": ["win32"],
       "cpu": ["arm64"]
     },
-    "@rollup/rollup-win32-ia32-msvc@4.52.2": {
+    "@rollup/rollup-win32-ia32-msvc@4.52.5": {
-      "integrity": "sha512-+GnYBmpjldD3XQd+HMejo+0gJGwYIOfFeoBQv32xF/RUIvccUz20/V6Otdv+57NE70D5pa8W/jVGDoGq0oON4A==",
+      "integrity": "sha512-Aufdpzp7DpOTULJCuvzqcItSGDH73pF3ko/f+ckJhxQyHtp67rHw3HMNxoIdDMUITJESNE6a8uh4Lo4SLouOUg==",
       "os": ["win32"],
       "cpu": ["ia32"]
     },
-    "@rollup/rollup-win32-x64-gnu@4.52.2": {
+    "@rollup/rollup-win32-x64-gnu@4.52.5": {
-      "integrity": "sha512-ApXFKluSB6kDQkAqZOKXBjiaqdF1BlKi+/eqnYe9Ee7U2K3pUDKsIyr8EYm/QDHTJIM+4X+lI0gJc3TTRhd+dA==",
+      "integrity": "sha512-UGBUGPFp1vkj6p8wCRraqNhqwX/4kNQPS57BCFc8wYh0g94iVIW33wJtQAx3G7vrjjNtRaxiMUylM0ktp/TRSQ==",
       "os": ["win32"],
       "cpu": ["x64"]
     },
-    "@rollup/rollup-win32-x64-msvc@4.52.2": {
+    "@rollup/rollup-win32-x64-msvc@4.52.5": {
-      "integrity": "sha512-ARz+Bs8kY6FtitYM96PqPEVvPXqEZmPZsSkXvyX19YzDqkCaIlhCieLLMI5hxO9SRZ2XtCtm8wxhy0iJ2jxNfw==",
+      "integrity": "sha512-TAcgQh2sSkykPRWLrdyy2AiceMckNf5loITqXxFI5VuQjS5tSuw3WlwdN8qv8vzjLAUTvYaH/mVjSFpbkFbpTg==",
       "os": ["win32"],
       "cpu": ["x64"]
     },
@@ -268,8 +268,8 @@
     "@types/trusted-types@2.0.7": {
       "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw=="
     },
-    "esbuild@0.25.10": {
+    "esbuild@0.25.12": {
-      "integrity": "sha512-9RiGKvCwaqxO2owP61uQ4BgNborAQskMR6QusfWzQqv7AZOg5oGehdY2pRJMTKuwxd1IDBP4rSbI5lHzU7SMsQ==",
+      "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==",
       "optionalDependencies": [
         "@esbuild/aix-ppc64",
         "@esbuild/android-arm",
@@ -355,8 +355,8 @@
         "source-map-js"
       ]
     },
-    "rollup@4.52.2": {
+    "rollup@4.52.5": {
-      "integrity": "sha512-I25/2QgoROE1vYV+NQ1En9T9UFB9Cmfm2CJ83zZOlaDpvz29wGQSZXWKw7MiNXau7wYgB/T9fVIdIuEQ+KbiiA==",
+      "integrity": "sha512-3GuObel8h7Kqdjt0gxkEzaifHTqLVW56Y/bjN7PSQtkKr0w3V/QYSdt6QWYtd7A1xUtYQigtdUfgj1RvWVtorw==",
       "dependencies": [
         "@types/estree"
       ],
@@ -397,8 +397,8 @@
         "picomatch"
       ]
     },
-    "vite@7.1.7_picomatch@4.0.3": {
+    "vite@7.1.12_picomatch@4.0.3": {
-      "integrity": "sha512-VbA8ScMvAISJNJVbRDTJdCwqQoAareR/wutevKanhR2/1EkoXVZVkkORaYm/tNVCjP/UDTKtcw3bAkwOUdedmA==",
+      "integrity": "sha512-ZWyE8YXEXqJrrSLvYgrRP7p62OziLW7xI5HYGWFzOvupfAlrLvURSzv/FyGyy0eidogEM3ujU+kUG1zuHgb6Ug==",
       "dependencies": [
         "esbuild",
         "fdir",
@@ -417,7 +417,7 @@
     "dependencies": [
       "npm:@deno/vite-plugin@^1.0.5",
       "npm:lit@^3.3.1",
-      "npm:vite@^7.1.7"
+      "npm:vite@^7.1.12"
     ]
   }
 }

crates/frontend/js-components/lib/create-birthday-calendar-form.ts

@@ -0,0 +1,102 @@
+import { html, LitElement } from "lit";
+import { customElement, property } from "lit/decorators.js";
+import { Ref, createRef, ref } from 'lit/directives/ref.js';
+import { escapeXml } from ".";
+import { getTimezones } from "./timezones.ts";
+
+@customElement("create-birthday-calendar-form")
+export class CreateCalendarForm extends LitElement {
+  protected override createRenderRoot() {
+    return this
+  }
+
+  @property()
+  principal: string = ''
+  @property()
+  addr_id: string = ''
+  @property()
+  displayname: string = ''
+  @property()
+  description: string = ''
+  @property()
+  color: string = ''
+
+  dialog: Ref<HTMLDialogElement> = createRef()
+  form: Ref<HTMLFormElement> = createRef()
+  @property()
+  timezones: Array<String> = []
+
+  override render() {
+    return html`
+      <button @click=${() => this.dialog.value.showModal()}>Create birthday calendar</button>
+      <dialog ${ref(this.dialog)}>
+        <h3>Create calendar</h3>
+        <form @submit=${this.submit} ${ref(this.form)}>
+          <label>
+            Displayname
+            <input type="text" name="displayname" value=${this.displayname} @change=${e => this.displayname = e.target.value} />
+          </label>
+          <br>
+          <label>
+            Description
+            <input type="text" name="description" @change=${e => this.description = e.target.value} />
+          </label>
+          <br>
+          <label>
+            Color
+            <input type="color" name="color"  @change=${e => this.color = e.target.value} />
+          </label>
+          <br>
+          <button type="submit">Create</button>
+          <button type="submit" @click=${event => { event.preventDefault(); this.dialog.value.close(); this.form.value.reset() }} class="cancel">Cancel</button>
+      </form>
+      </dialog>
+        `
+  }
+
+  async submit(e: SubmitEvent) {
+    e.preventDefault()
+    if (!this.addr_id) {
+      alert("Empty id")
+      return
+    }
+    if (!this.displayname) {
+      alert("Empty displayname")
+      return
+    }
+
+    let response = await fetch(`/caldav/principal/${this.principal}/_birthdays_${this.addr_id}`, {
+      method: 'MKCOL',
+      headers: {
+        'Content-Type': 'application/xml'
+      },
+      body: `
+      <mkcol xmlns="DAV:" xmlns:CAL="urn:ietf:params:xml:ns:caldav" xmlns:CS="http://calendarserver.org/ns/" xmlns:ICAL="http://apple.com/ns/ical/">
+        <set>
+          <prop>
+            <displayname>${escapeXml(this.displayname)}</displayname>
+            ${this.description ? `<CAL:calendar-description>${escapeXml(this.description)}</CAL:calendar-description>` : ''}
+            ${this.color ? `<ICAL:calendar-color>${escapeXml(this.color)}</ICAL:calendar-color>` : ''}
+            <CAL:supported-calendar-component-set>
+              <CAL:comp name="VEVENT" />
+            </CAL:supported-calendar-component-set>
+          </prop>
+        </set>
+      </mkcol>
+      `
+    })
+
+    if (response.status >= 400) {
+      alert(`Error ${response.status}: ${await response.text()}`)
+      return null
+    }
+    window.location.reload()
+    return null
+  }
+}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    'create-calendar-form': CreateCalendarForm
+  }
+}

crates/frontend/js-components/lib/create-calendar-form.ts

@@ -2,11 +2,17 @@ import { html, LitElement } from "lit";
 import { customElement, property } from "lit/decorators.js";
 import { Ref, createRef, ref } from 'lit/directives/ref.js';
 import { escapeXml } from ".";
+import { getTimezones } from "./timezones.ts";
 
 @customElement("create-calendar-form")
 export class CreateCalendarForm extends LitElement {
   constructor() {
     super()
+    this.fetchTimezones()
+  }
+
+  async fetchTimezones() {
+    this.timezones = await getTimezones()
   }
 
   protected override createRenderRoot() {
@@ -36,6 +42,8 @@ export class CreateCalendarForm extends LitElement {
 
   dialog: Ref<HTMLDialogElement> = createRef()
   form: Ref<HTMLFormElement> = createRef()
+  @property()
+  timezones: Array<String> = []
 
   override render() {
     return html`
@@ -65,7 +73,12 @@ export class CreateCalendarForm extends LitElement {
           <br>
           <label>
             Timezone (optional)
-            <input type="text" name="timezone" .value=${this.timezone_id} @change=${e => this.timezone_id = e.target.value} />
+            <select name="timezone" .value=${this.timezone_id} @change=${e => this.timezone_id = e.target.value}>
+              <option value="">No timezone</option>
+              ${this.timezones.map(timezone => html`
+                <option value=${timezone} ?selected=${timezone === this.timezone_id}>${timezone}</option>
+              `)}
+            </select>
           </label>
           <br>
           <label>

crates/frontend/js-components/lib/edit-calendar-form.ts

@@ -2,11 +2,17 @@ import { html, LitElement } from "lit";
 import { customElement, property } from "lit/decorators.js";
 import { Ref, createRef, ref } from 'lit/directives/ref.js';
 import { escapeXml } from ".";
+import { getTimezones } from "./timezones.ts";
 
 @customElement("edit-calendar-form")
 export class EditCalendarForm extends LitElement {
   constructor() {
     super()
+    this.fetchTimezones()
+  }
+
+  async fetchTimezones() {
+    this.timezones = await getTimezones()
   }
 
   protected override createRenderRoot() {
@@ -36,7 +42,8 @@ export class EditCalendarForm extends LitElement {
 
   dialog: Ref<HTMLDialogElement> = createRef()
   form: Ref<HTMLFormElement> = createRef()
-
+  @property()
+  timezones: Array<String> = []
 
   override render() {
     return html`
@@ -51,7 +58,12 @@ export class EditCalendarForm extends LitElement {
           <br>
           <label>
             Timezone (optional)
-            <input type="text" name="timezone" .value=${this.timezone_id} @change=${e => this.timezone_id = e.target.value} />
+            <select name="timezone" .value=${this.timezone_id} @change=${e => this.timezone_id = e.target.value}>
+              <option value="">No timezone</option>
+              ${this.timezones.map(timezone => html`
+                <option value=${timezone} ?selected=${timezone === this.timezone_id}>${timezone}</option>
+              `)}
+            </select>
           </label>
           <br>
           <label>

crates/frontend/js-components/lib/timezones.ts

@@ -0,0 +1,12 @@
+let timezonesPromise = null
+export async function getTimezones() {
+  timezonesPromise ||= new Promise(async (resolve, reject) => {
+    try {
+      let response = await fetch('/frontend/_timezones.json')
+      resolve(await response.json())
+    } catch (e) {
+      reject(e)
+    }
+  })
+  return await timezonesPromise
+}

crates/frontend/js-components/vite.config.ts

@@ -14,6 +14,7 @@ export default defineConfig({
 
     rollupOptions: {
       input: [
+        "lib/create-birthday-calendar-form.ts",
         "lib/create-calendar-form.ts",
         "lib/edit-calendar-form.ts",
         "lib/import-calendar-form.ts",

crates/frontend/public/assets/js/create-birthday-calendar-form.mjs

@@ -0,0 +1,122 @@
+import { i, x } from "./lit-DkXrt_Iv.mjs";
+import { n as n$1, t } from "./property-B8WoKf1Y.mjs";
+import { e, n } from "./ref-BwbQvJBB.mjs";
+import { e as escapeXml } from "./index-_IB1wMbZ.mjs";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i2 = decorators.length - 1, decorator; i2 >= 0; i2--)
+    if (decorator = decorators[i2])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+let CreateCalendarForm = class extends i {
+  constructor() {
+    super(...arguments);
+    this.principal = "";
+    this.addr_id = "";
+    this.displayname = "";
+    this.description = "";
+    this.color = "";
+    this.dialog = e();
+    this.form = e();
+    this.timezones = [];
+  }
+  createRenderRoot() {
+    return this;
+  }
+  render() {
+    return x`
+      <button @click=${() => this.dialog.value.showModal()}>Create birthday calendar</button>
+      <dialog ${n(this.dialog)}>
+        <h3>Create calendar</h3>
+        <form @submit=${this.submit} ${n(this.form)}>
+          <label>
+            Displayname
+            <input type="text" name="displayname" value=${this.displayname} @change=${(e2) => this.displayname = e2.target.value} />
+          </label>
+          <br>
+          <label>
+            Description
+            <input type="text" name="description" @change=${(e2) => this.description = e2.target.value} />
+          </label>
+          <br>
+          <label>
+            Color
+            <input type="color" name="color"  @change=${(e2) => this.color = e2.target.value} />
+          </label>
+          <br>
+          <button type="submit">Create</button>
+          <button type="submit" @click=${(event) => {
+      event.preventDefault();
+      this.dialog.value.close();
+      this.form.value.reset();
+    }} class="cancel">Cancel</button>
+      </form>
+      </dialog>
+        `;
+  }
+  async submit(e2) {
+    e2.preventDefault();
+    if (!this.addr_id) {
+      alert("Empty id");
+      return;
+    }
+    if (!this.displayname) {
+      alert("Empty displayname");
+      return;
+    }
+    let response = await fetch(`/caldav/principal/${this.principal}/_birthdays_${this.addr_id}`, {
+      method: "MKCOL",
+      headers: {
+        "Content-Type": "application/xml"
+      },
+      body: `
+      <mkcol xmlns="DAV:" xmlns:CAL="urn:ietf:params:xml:ns:caldav" xmlns:CS="http://calendarserver.org/ns/" xmlns:ICAL="http://apple.com/ns/ical/">
+        <set>
+          <prop>
+            <displayname>${escapeXml(this.displayname)}</displayname>
+            ${this.description ? `<CAL:calendar-description>${escapeXml(this.description)}</CAL:calendar-description>` : ""}
+            ${this.color ? `<ICAL:calendar-color>${escapeXml(this.color)}</ICAL:calendar-color>` : ""}
+            <CAL:supported-calendar-component-set>
+              <CAL:comp name="VEVENT" />
+            </CAL:supported-calendar-component-set>
+          </prop>
+        </set>
+      </mkcol>
+      `
+    });
+    if (response.status >= 400) {
+      alert(`Error ${response.status}: ${await response.text()}`);
+      return null;
+    }
+    window.location.reload();
+    return null;
+  }
+};
+__decorateClass([
+  n$1()
+], CreateCalendarForm.prototype, "principal", 2);
+__decorateClass([
+  n$1()
+], CreateCalendarForm.prototype, "addr_id", 2);
+__decorateClass([
+  n$1()
+], CreateCalendarForm.prototype, "displayname", 2);
+__decorateClass([
+  n$1()
+], CreateCalendarForm.prototype, "description", 2);
+__decorateClass([
+  n$1()
+], CreateCalendarForm.prototype, "color", 2);
+__decorateClass([
+  n$1()
+], CreateCalendarForm.prototype, "timezones", 2);
+CreateCalendarForm = __decorateClass([
+  t("create-birthday-calendar-form")
+], CreateCalendarForm);
+export {
+  CreateCalendarForm
+};

crates/frontend/public/assets/js/create-calendar-form.mjs

@@ -2,6 +2,7 @@ import { i, x } from "./lit-DkXrt_Iv.mjs";
 import { n as n$1, t } from "./property-B8WoKf1Y.mjs";
 import { e, n } from "./ref-BwbQvJBB.mjs";
 import { e as escapeXml } from "./index-_IB1wMbZ.mjs";
+import { g as getTimezones } from "./timezones-B0vBBzCP.mjs";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -27,6 +28,11 @@ let CreateCalendarForm = class extends i {
     this.components = /* @__PURE__ */ new Set();
     this.dialog = e();
     this.form = e();
+    this.timezones = [];
+    this.fetchTimezones();
+  }
+  async fetchTimezones() {
+    this.timezones = await getTimezones();
   }
   createRenderRoot() {
     return this;
@@ -59,7 +65,12 @@ let CreateCalendarForm = class extends i {
           <br>
           <label>
             Timezone (optional)
-            <input type="text" name="timezone" .value=${this.timezone_id} @change=${(e2) => this.timezone_id = e2.target.value} />
+            <select name="timezone" .value=${this.timezone_id} @change=${(e2) => this.timezone_id = e2.target.value}>
+              <option value="">No timezone</option>
+              ${this.timezones.map((timezone) => x`
+                <option value=${timezone} ?selected=${timezone === this.timezone_id}>${timezone}</option>
+              `)}
+            </select>
           </label>
           <br>
           <label>
@@ -179,6 +190,9 @@ __decorateClass([
 __decorateClass([
   n$1()
 ], CreateCalendarForm.prototype, "components", 2);
+__decorateClass([
+  n$1()
+], CreateCalendarForm.prototype, "timezones", 2);
 CreateCalendarForm = __decorateClass([
   t("create-calendar-form")
 ], CreateCalendarForm);

crates/frontend/public/assets/js/edit-calendar-form.mjs

@@ -2,6 +2,7 @@ import { i, x } from "./lit-DkXrt_Iv.mjs";
 import { n as n$1, t } from "./property-B8WoKf1Y.mjs";
 import { e, n } from "./ref-BwbQvJBB.mjs";
 import { e as escapeXml } from "./index-_IB1wMbZ.mjs";
+import { g as getTimezones } from "./timezones-B0vBBzCP.mjs";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __decorateClass = (decorators, target, key, kind) => {
@@ -22,6 +23,11 @@ let EditCalendarForm = class extends i {
     this.components = /* @__PURE__ */ new Set();
     this.dialog = e();
     this.form = e();
+    this.timezones = [];
+    this.fetchTimezones();
+  }
+  async fetchTimezones() {
+    this.timezones = await getTimezones();
   }
   createRenderRoot() {
     return this;
@@ -39,7 +45,12 @@ let EditCalendarForm = class extends i {
           <br>
           <label>
             Timezone (optional)
-            <input type="text" name="timezone" .value=${this.timezone_id} @change=${(e2) => this.timezone_id = e2.target.value} />
+            <select name="timezone" .value=${this.timezone_id} @change=${(e2) => this.timezone_id = e2.target.value}>
+              <option value="">No timezone</option>
+              ${this.timezones.map((timezone) => x`
+                <option value=${timezone} ?selected=${timezone === this.timezone_id}>${timezone}</option>
+              `)}
+            </select>
           </label>
           <br>
           <label>
@@ -150,6 +161,9 @@ __decorateClass([
     }
   })
 ], EditCalendarForm.prototype, "components", 2);
+__decorateClass([
+  n$1()
+], EditCalendarForm.prototype, "timezones", 2);
 EditCalendarForm = __decorateClass([
   t("edit-calendar-form")
 ], EditCalendarForm);

crates/frontend/public/assets/js/timezones-B0vBBzCP.mjs

@@ -0,0 +1,15 @@
+let timezonesPromise = null;
+async function getTimezones() {
+  timezonesPromise ||= new Promise(async (resolve, reject) => {
+    try {
+      let response = await fetch("/frontend/_timezones.json");
+      resolve(await response.json());
+    } catch (e) {
+      reject(e);
+    }
+  });
+  return await timezonesPromise;
+}
+export {
+  getTimezones as g
+};

crates/frontend/public/assets/style.css

@@ -53,6 +53,11 @@ a {
   color: var(--text-on-background-color);
 }
 
+a,
+button {
+  cursor: pointer;
+}
+
 header {
   background: var(--background-darker);
   min-height: 60px;
@@ -79,9 +84,6 @@ header {
   nav {
     display: flex;
 
-    border-radius: 12px;
-    background: color-mix(in srgb, var(--background-darker), var(--dilute-color) 5%);
-
     a {
       text-decoration: none;
       margin: 4px 8px;
@@ -242,10 +244,8 @@ ul.collection-list {
       z-index: 1;
       pointer-events: none;
 
-      a,
       button {
         pointer-events: all;
-        cursor: pointer;
       }
 
       .title {
@@ -259,19 +259,6 @@ ul.collection-list {
         margin: 8px initial;
       }
 
-      .comps {
-        display: inline;
-
-        span {
-          margin: 0 2px;
-          background: var(--primary-color);
-          color: var(--text-on-primary-color);
-          font-size: .8em;
-          padding: 3px 8px;
-          border-radius: 12px;
-        }
-      }
-
       .description {
         grid-area: description;
         white-space: nowrap;
@@ -298,6 +285,7 @@ ul.collection-list {
         grid-area: actions;
         width: fit-content;
         display: flex;
+        flex-wrap: wrap;
         gap: 12px;
       }
     }
@@ -363,3 +351,16 @@ svg.icon {
   color: var(--text-on-background-color);
   stroke: var(--text-on-background-color);
 }
+
+.component-chips {
+  display: inline;
+
+  span.chip {
+    margin: 0 2px;
+    background: var(--primary-color);
+    color: var(--text-on-primary-color);
+    font-size: .8em;
+    padding: 3px 8px;
+    border-radius: 12px;
+  }
+}

crates/frontend/public/templates/components/sections/addressbooks_section.html

@@ -1,6 +1,6 @@
 <h2>{{user.id }}'s Addressbooks</h2>
 <ul class="collection-list">
-  {% for (meta, addressbook) in addressbooks %}
+  {% for (meta, birthday_cal, addressbook) in addressbooks %}
   <li class="collection-list-item">
     <a href="/frontend/user/{{ addressbook.principal }}/addressbook/{{ addressbook.id}}"></a>
     <div class="inner">
@@ -24,9 +24,17 @@
         ></edit-addressbook-form>
         <delete-button trash
           href="/carddav/principal/{{ addressbook.principal }}/{{ addressbook.id }}"></delete-button>
+        {% if !birthday_cal.is_some() %}
+        <create-birthday-calendar-form
+          principal="{{ addressbook.principal }}"
+          addr_id="{{ addressbook.id }}"
+          displayname="{{ addressbook.displayname.as_deref().unwrap_or_default() }} birthdays"
+        ></create-birthday-calendar-form>
+        {% endif %}
       </div>
       <div class="metadata">
         {{ meta.len }} ({{ meta.size | filesizeformat }}) objects, {{ meta.deleted_len }} ({{ meta.deleted_size | filesizeformat }}) deleted objects
+        {{ birthday_cal.is_some() }}
       </div>
     </div>
   </li>
@@ -37,7 +45,7 @@
 {%if !deleted_addressbooks.is_empty() %}
 <h3>Deleted Addressbooks</h3>
 <ul class="collection-list">
-  {% for (meta, addressbook) in deleted_addressbooks %}
+  {% for (meta, birthday_cal, addressbook) in deleted_addressbooks %}
   <li class="collection-list-item">
     <a href="/frontend/user/{{ addressbook.principal }}/addressbook/{{ addressbook.id}}"></a>
     <div class="inner">

crates/frontend/public/templates/components/sections/calendars_section.html

@@ -8,9 +8,9 @@
       <span class="title">
         {%- if calendar.principal != user.id -%}{{ calendar.principal }}/{%- endif -%}
         {{ calendar.meta.displayname.to_owned().unwrap_or(calendar.id.to_owned()) }}
-        <div class="comps">
+        <div class="component-chips">
           {% for comp in calendar.components %}
-          <span>{{ comp }}</span>
+          <span class="chip">{{ comp }}</span>
           {% endfor %}
         </div>
       </span>
@@ -24,7 +24,6 @@
         <form action="/caldav/principal/{{ calendar.principal }}/{{ calendar.id }}" target="_blank" method="GET">
           <button type="submit">Download</button>
         </form>
-        {% if !calendar.id.starts_with("_birthdays_") %}
         <edit-calendar-form
           principal="{{ calendar.principal }}"
           cal_id="{{ calendar.id }}"
@@ -35,7 +34,6 @@
           components="{{ calendar.components | json }}"
         ></edit-calendar-form>
         <delete-button trash href="/caldav/principal/{{ calendar.principal }}/{{ calendar.id }}"></delete-button>
-        {% endif %}
       </div>
       <div class="metadata">
         {{ meta.len }} ({{ meta.size | filesizeformat }}) objects, {{ meta.deleted_len }} ({{ meta.deleted_size | filesizeformat }}) deleted objects
@@ -58,9 +56,9 @@
       <span class="title">
         {%- if calendar.principal != user.id -%}{{ calendar.principal }}/{%- endif -%}
         {{ calendar.meta.displayname.to_owned().unwrap_or(calendar.id.to_owned()) }}
-        <div class="comps">
+        <div class="component-chips">
           {% for comp in calendar.components %}
-          <span>{{ comp }}</span>
+          <span class="chip">{{ comp }}</span>
           {% endfor %}
         </div>
       </span>
@@ -85,4 +83,3 @@
 {% endif %}
 <create-calendar-form user="{{ user.id }}"></create-calendar-form>
 <import-calendar-form user="{{ user.id }}"></import-calendar-form>
-

crates/frontend/public/templates/layouts/default.html

@@ -14,9 +14,11 @@
   <header>
       <a class="logo" href="/frontend/user">RustiCal</a>
       {% block header_center %}{% endblock %}
+      {% if self.get_user().is_some() %}
         <form method="POST" action="/frontend/logout" class="logout_form">
           <button type="submit">Log out</button>
         </form>
+      {% endif %}
   </header>
   {% endblock %}
   <div id="app">

crates/frontend/public/templates/pages/addressbook.html

@@ -8,6 +8,7 @@
 <h1>{{ name }}</h1>
 {% if let Some(description) = addressbook.description %}<p>{{ description }}</p>{% endif%}
 
-<pre>{{ addressbook|json }}</pre>
+<h2>Debug information</h2>
+<pre>{{ addressbook|json(2) }}</pre>
 
 {% endblock %}

crates/frontend/public/templates/pages/calendar.html

@@ -5,7 +5,15 @@
 
 {% block content %}
 {% let name = calendar.meta.displayname.to_owned().unwrap_or(calendar.id.to_owned()) %}
-<h1>{{ calendar.principal }}/{{ name }}</h1>
+<h1>
+  {{ calendar.principal }}/{{ name }}
+  <div class="component-chips">
+    {% for comp in calendar.components %}
+    <span class="chip">{{ comp }}</span>
+    {% endfor %}
+  </div>
+
+</h1>
 {% if let Some(description) = calendar.meta.description %}<p>{{ description }}</p>{% endif%}
 
 {% if let Some(subscription_url) = calendar.subscription_url %}
@@ -13,19 +21,7 @@
 <a href="{{ subscription_url }}">{{ subscription_url }}</a>
 {% endif %}
 
-<h2>Components</h2>
+<h2>Debug information</h2>
-<ul>
+<pre>{{ calendar|json(2) }}</pre>
-  {% for comp in calendar.components %}
-  <li>{{ comp.as_str() }}</li>
-  {% endfor %}
-</ul>
-
-<h2>Timezone</h2>
-
-{% if let Some(timezone_id) = calendar.timezone_id %}
-<p>{{ timezone_id }}</p>
-{% endif %}
-
-<pre>{{ calendar|json }}</pre>
 
 {%endblock %}

crates/frontend/public/templates/pages/user.html

@@ -5,6 +5,7 @@
 <script>
 window.rusticalUser = JSON.parse(document.querySelector('#data-rustical-user').innerHTML)
 </script>
+<script type="module" src="/frontend/assets/js/create-birthday-calendar-form.mjs" async></script>
 <script type="module" src="/frontend/assets/js/create-calendar-form.mjs" async></script>
 <script type="module" src="/frontend/assets/js/edit-calendar-form.mjs" async></script>
 <script type="module" src="/frontend/assets/js/import-calendar-form.mjs" async></script>

crates/frontend/src/lib.rs

@@ -12,7 +12,7 @@ use http::{Method, StatusCode};
 use routes::{addressbooks::route_addressbooks, calendars::route_calendars};
 use rustical_oidc::{OidcConfig, OidcServiceConfig, route_get_oidc_callback, route_post_oidc};
 use rustical_store::{
-    AddressbookStore, CalendarStore,
+    AddressbookStore, CalendarStore, PrefixedCalendarStore,
     auth::{AuthenticationProvider, middleware::AuthenticationLayer},
 };
 use std::sync::Arc;
@@ -33,12 +33,17 @@ use crate::routes::{
     app_token::{route_delete_app_token, route_post_app_token},
     calendar::{route_calendar, route_calendar_restore},
     login::{route_get_login, route_post_login, route_post_logout},
+    timezones::route_timezones,
     user::{route_get_home, route_root, route_user_named},
 };
 #[cfg(not(feature = "dev"))]
 use assets::{Assets, EmbedService};
 
-pub fn frontend_router<AP: AuthenticationProvider, CS: CalendarStore, AS: AddressbookStore>(
+pub fn frontend_router<
+    AP: AuthenticationProvider,
+    CS: CalendarStore,
+    AS: AddressbookStore + PrefixedCalendarStore,
+>(
     prefix: &'static str,
     auth_provider: Arc<AP>,
     cal_store: Arc<CS>,
@@ -79,7 +84,11 @@ pub fn frontend_router<AP: AuthenticationProvider, CS: CalendarStore, AS: Addres
         .route("/", get(route_root))
         .nest("/user", user_router)
         .route("/login", get(route_get_login).post(route_post_login::<AP>))
-        .route("/logout", post(route_post_logout));
+        .route("/logout", post(route_post_logout))
+        .route(
+            "/_timezones.json",
+            get(route_timezones).head(route_timezones),
+        );
 
     #[cfg(not(feature = "dev"))]
     let mut router = router.route_service("/assets/{*file}", EmbedService::<Assets>::default());

crates/frontend/src/nextcloud_login/routes.rs

@@ -2,7 +2,7 @@ use super::{
     NextcloudFlow, NextcloudFlows, NextcloudLoginPoll, NextcloudLoginResponse,
     NextcloudSuccessResponse,
 };
-use crate::routes::app_token::generate_app_token;
+use crate::{pages::DefaultLayoutData, routes::app_token::generate_app_token};
 use askama::Template;
 use axum::{
     Extension, Form, Json,
@@ -100,6 +100,12 @@ struct NextcloudLoginPage {
     app_name: String,
 }
 
+impl DefaultLayoutData for NextcloudLoginPage {
+    fn get_user(&self) -> Option<&Principal> {
+        None
+    }
+}
+
 #[instrument(skip(state))]
 pub async fn get_nextcloud_flow(
     Extension(state): Extension<Arc<NextcloudFlows>>,
@@ -130,6 +136,13 @@ pub struct NextcloudAuthorizeForm {
 #[template(path = "pages/nextcloud_login/success.html")]
 struct NextcloudLoginSuccessPage {
     app_name: String,
+    user: Principal,
+}
+
+impl DefaultLayoutData for NextcloudLoginSuccessPage {
+    fn get_user(&self) -> Option<&Principal> {
+        Some(&self.user)
+    }
 }
 
 #[instrument(skip(state))]
@@ -150,6 +163,7 @@ pub async fn post_nextcloud_flow(
         Ok(Html(
             NextcloudLoginSuccessPage {
                 app_name: flow.app_name.clone(),
+                user,
             }
             .render()
             .unwrap(),

crates/frontend/src/pages/mod.rs

@@ -1 +1,8 @@
+use rustical_store::auth::Principal;
+
 pub mod user;
+
+/// Required by the base layout
+pub trait DefaultLayoutData {
+    fn get_user(&self) -> Option<&Principal>;
+}

crates/frontend/src/pages/user.rs

@@ -2,6 +2,8 @@ use askama::Template;
 use askama_web::WebTemplate;
 use rustical_store::auth::Principal;
 
+use crate::pages::DefaultLayoutData;
+
 pub trait Section: Template {
     fn name() -> &'static str;
 }
@@ -12,3 +14,9 @@ pub struct UserPage<S: Section> {
     pub user: Principal,
     pub section: S,
 }
+
+impl<S: Section> DefaultLayoutData for UserPage<S> {
+    fn get_user(&self) -> Option<&Principal> {
+        Some(&self.user)
+    }
+}

crates/frontend/src/routes/addressbook.rs

@@ -12,10 +12,19 @@ use headers::Referer;
 use http::StatusCode;
 use rustical_store::{Addressbook, AddressbookStore, auth::Principal};
 
+use crate::pages::DefaultLayoutData;
+
 #[derive(Template, WebTemplate)]
 #[template(path = "pages/addressbook.html")]
 struct AddressbookPage {
     addressbook: Addressbook,
+    user: Principal,
+}
+
+impl DefaultLayoutData for AddressbookPage {
+    fn get_user(&self) -> Option<&Principal> {
+        Some(&self.user)
+    }
 }
 
 pub async fn route_addressbook<AS: AddressbookStore>(
@@ -28,6 +37,7 @@ pub async fn route_addressbook<AS: AddressbookStore>(
     }
     Ok(AddressbookPage {
         addressbook: store.get_addressbook(&owner, &addrbook_id, true).await?,
+        user,
     }
     .into_response())
 }

crates/frontend/src/routes/addressbooks.rs

@@ -1,10 +1,12 @@
-use std::sync::Arc;
-
 use askama::Template;
 use askama_web::WebTemplate;
 use axum::{Extension, extract::Path, response::IntoResponse};
 use http::StatusCode;
-use rustical_store::{Addressbook, AddressbookStore, CollectionMetadata, auth::Principal};
+use rustical_store::{
+    Addressbook, AddressbookStore, Calendar, CollectionMetadata, PrefixedCalendarStore,
+    auth::Principal,
+};
+use std::sync::Arc;
 
 use crate::pages::user::{Section, UserPage};
 
@@ -18,11 +20,11 @@ impl Section for AddressbooksSection {
 #[template(path = "components/sections/addressbooks_section.html")]
 pub struct AddressbooksSection {
     pub user: Principal,
-    pub addressbooks: Vec<(CollectionMetadata, Addressbook)>,
+    pub addressbooks: Vec<(CollectionMetadata, Option<Calendar>, Addressbook)>,
-    pub deleted_addressbooks: Vec<(CollectionMetadata, Addressbook)>,
+    pub deleted_addressbooks: Vec<(CollectionMetadata, Option<Calendar>, Addressbook)>,
 }
 
-pub async fn route_addressbooks<AS: AddressbookStore>(
+pub async fn route_addressbooks<AS: AddressbookStore + PrefixedCalendarStore>(
     Path(user_id): Path<String>,
     Extension(addr_store): Extension<Arc<AS>>,
     user: Principal,
@@ -43,22 +45,42 @@ pub async fn route_addressbooks<AS: AddressbookStore>(
 
     let mut addressbook_infos = vec![];
     for addressbook in addressbooks {
+        let birthday_id = format!("{}{}", AS::PREFIX, &addressbook.id);
+        let birthday_cal = match addr_store
+            .get_calendar(&addressbook.principal, &birthday_id, true)
+            .await
+        {
+            Ok(cal) => Some(cal),
+            Err(rustical_store::Error::NotFound) => None,
+            err => Some(err.unwrap()),
+        };
         addressbook_infos.push((
             addr_store
                 .addressbook_metadata(&addressbook.principal, &addressbook.id)
                 .await
                 .unwrap(),
+            birthday_cal,
             addressbook,
         ));
     }
 
     let mut deleted_addressbook_infos = vec![];
     for addressbook in deleted_addressbooks {
+        let birthday_id = format!("{}{}", AS::PREFIX, &addressbook.id);
+        let birthday_cal = match addr_store
+            .get_calendar(&addressbook.principal, &birthday_id, true)
+            .await
+        {
+            Ok(cal) => Some(cal),
+            Err(rustical_store::Error::NotFound) => None,
+            err => Some(err.unwrap()),
+        };
         deleted_addressbook_infos.push((
             addr_store
                 .addressbook_metadata(&addressbook.principal, &addressbook.id)
                 .await
                 .unwrap(),
+            birthday_cal,
             addressbook,
         ));
     }

crates/frontend/src/routes/calendar.rs

@@ -1,5 +1,4 @@
-use std::sync::Arc;
+use crate::pages::DefaultLayoutData;
-
 use askama::Template;
 use askama_web::WebTemplate;
 use axum::{
@@ -11,11 +10,19 @@ use axum_extra::TypedHeader;
 use headers::Referer;
 use http::StatusCode;
 use rustical_store::{Calendar, CalendarStore, auth::Principal};
+use std::sync::Arc;
 
 #[derive(Template, WebTemplate)]
 #[template(path = "pages/calendar.html")]
 struct CalendarPage {
     calendar: Calendar,
+    user: Principal,
+}
+
+impl DefaultLayoutData for CalendarPage {
+    fn get_user(&self) -> Option<&Principal> {
+        Some(&self.user)
+    }
 }
 
 pub async fn route_calendar<C: CalendarStore>(
@@ -28,6 +35,7 @@ pub async fn route_calendar<C: CalendarStore>(
     }
     Ok(CalendarPage {
         calendar: store.get_calendar(&owner, &cal_id, true).await?,
+        user,
     }
     .into_response())
 }

crates/frontend/src/routes/login.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use crate::{FrontendConfig, OidcConfig};
+use crate::{FrontendConfig, OidcConfig, pages::DefaultLayoutData};
 use askama::Template;
 use askama_web::WebTemplate;
 use axum::{
@@ -24,6 +24,12 @@ struct LoginPage<'a> {
     allow_password_login: bool,
 }
 
+impl DefaultLayoutData for LoginPage<'_> {
+    fn get_user(&self) -> Option<&rustical_store::auth::Principal> {
+        None
+    }
+}
+
 struct OidcProviderData<'a> {
     pub name: &'a str,
     pub redirect_url: String,

crates/frontend/src/routes/mod.rs

@@ -4,4 +4,5 @@ pub mod app_token;
 pub mod calendar;
 pub mod calendars;
 pub mod login;
+pub mod timezones;
 pub mod user;

crates/frontend/src/routes/timezones.rs

@@ -0,0 +1,39 @@
+use headers::{CacheControl, ContentType, HeaderMapExt};
+use http::{HeaderMap, HeaderValue, Method};
+use itertools::Itertools;
+use std::{sync::LazyLock, time::Duration};
+
+static VTIMEZONES_JSON: LazyLock<String> = LazyLock::new(|| {
+    serde_json::to_string(
+        &vtimezones_rs::VTIMEZONES
+            .keys()
+            .sorted()
+            .collect::<Vec<_>>(),
+    )
+    .unwrap()
+});
+
+pub async fn route_timezones(method: Method) -> (HeaderMap, &'static str) {
+    let mut headers = HeaderMap::new();
+    headers.typed_insert(ContentType::json());
+    headers.insert(
+        "ETag",
+        HeaderValue::from_static(vtimezones_rs::IANA_TZDB_VERSION),
+    );
+    headers.typed_insert(CacheControl::new().with_max_age(Duration::from_hours(2)));
+
+    if method == Method::HEAD {
+        return (headers, "");
+    }
+    (headers, VTIMEZONES_JSON.as_str())
+}
+
+#[cfg(test)]
+#[tokio::test]
+async fn test_vtimezones_json() -> () {
+    // Since there's an unwrap make sure this doesn't fail
+    assert!(!VTIMEZONES_JSON.as_str().is_empty());
+
+    assert!(route_timezones(Method::HEAD).await.1.is_empty());
+    assert!(!route_timezones(Method::GET).await.1.is_empty());
+}

crates/ical/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "rustical_ical"
 version.workspace = true
+rust-version.workspace = true
 edition.workspace = true
 description.workspace = true
 repository.workspace = true

crates/ical/src/address_object.rs

@@ -97,7 +97,8 @@ impl AddressObject {
                 let uid = format!("{}-anniversary", self.get_id());
 
                 let year_suffix = year.map(|year| format!(" ({year})")).unwrap_or_default();
-                Some(CalendarObject::from_ics(format!(
+                Some(CalendarObject::from_ics(
+                    format!(
                         r"BEGIN:VCALENDAR
 VERSION:2.0
 CALSCALE:GREGORIAN
@@ -116,7 +117,9 @@ DESCRIPTION:💍 {fullname}{year_suffix}
 END:VALARM
 END:VEVENT
 END:VCALENDAR",
-                ))?)
+                    ),
+                    None,
+                )?)
             } else {
                 None
             },
@@ -136,7 +139,8 @@ END:VCALENDAR",
                 let uid = format!("{}-birthday", self.get_id());
 
                 let year_suffix = year.map(|year| format!(" ({year})")).unwrap_or_default();
-                Some(CalendarObject::from_ics(format!(
+                Some(CalendarObject::from_ics(
+                    format!(
                         r"BEGIN:VCALENDAR
 VERSION:2.0
 CALSCALE:GREGORIAN
@@ -155,7 +159,9 @@ DESCRIPTION:🎂 {fullname}{year_suffix}
 END:VALARM
 END:VEVENT
 END:VCALENDAR",
-                ))?)
+                    ),
+                    None,
+                )?)
             } else {
                 None
             },

crates/ical/src/error.rs

@@ -2,7 +2,7 @@ use axum::{http::StatusCode, response::IntoResponse};
 
 use crate::CalDateTimeError;
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, thiserror::Error, PartialEq, Eq)]
 pub enum Error {
     #[error("Invalid ics/vcf input: {0}")]
     InvalidData(String),

crates/ical/src/icalendar/event.rs

@@ -251,7 +251,7 @@ END:VEVENT\r\n",
 
     #[test]
     fn test_expand_recurrence() {
-        let event = CalendarObject::from_ics(ICS.to_string()).unwrap();
+        let event = CalendarObject::from_ics(ICS.to_string(), None).unwrap();
         let crate::CalendarObjectComponent::Event(event, overrides) = event.get_data() else {
             panic!()
         };

crates/ical/src/icalendar/object.rs

@@ -64,6 +64,19 @@ pub enum CalendarObjectComponent {
     Journal(IcalJournal, Vec<IcalJournal>),
 }
 
+impl CalendarObjectComponent {
+    #[must_use]
+    pub fn get_uid(&self) -> &str {
+        match &self {
+            // We've made sure before that the first component exists and all components share the
+            // same UID
+            Self::Todo(todo, _) => todo.get_uid(),
+            Self::Event(event, _) => event.event.get_uid(),
+            Self::Journal(journal, _) => journal.get_uid(),
+        }
+    }
+}
+
 impl From<&CalendarObjectComponent> for CalendarObjectType {
     fn from(value: &CalendarObjectComponent) -> Self {
         match value {
@@ -135,18 +148,47 @@ impl CalendarObjectComponent {
         }
         Ok(Self::Journal(main_journal, overrides))
     }
+
+    pub fn get_first_occurence(&self) -> Result<Option<CalDateTime>, Error> {
+        match &self {
+            Self::Event(main_event, overrides) => Ok(overrides
+                .iter()
+                .chain(std::iter::once(main_event))
+                .map(super::event::EventObject::get_dtstart)
+                .collect::<Result<Vec<_>, _>>()?
+                .into_iter()
+                .flatten()
+                .min()),
+            _ => Ok(None),
+        }
+    }
+
+    pub fn get_last_occurence(&self) -> Result<Option<CalDateTime>, Error> {
+        match &self {
+            Self::Event(main_event, overrides) => Ok(overrides
+                .iter()
+                .chain(std::iter::once(main_event))
+                .map(super::event::EventObject::get_last_occurence)
+                .collect::<Result<Vec<_>, _>>()?
+                .into_iter()
+                .flatten()
+                .max()),
+            _ => Ok(None),
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
 pub struct CalendarObject {
     data: CalendarObjectComponent,
     properties: Vec<Property>,
+    id: String,
     ics: String,
     vtimezones: HashMap<String, IcalTimeZone>,
 }
 
 impl CalendarObject {
-    pub fn from_ics(ics: String) -> Result<Self, Error> {
+    pub fn from_ics(ics: String, id: Option<String>) -> Result<Self, Error> {
         let mut parser = ical::IcalParser::new(BufReader::new(ics.as_bytes()));
         let cal = parser.next().ok_or(Error::MissingCalendar)??;
         if parser.next().is_some() {
@@ -202,6 +244,7 @@ impl CalendarObject {
         };
 
         Ok(Self {
+            id: id.unwrap_or_else(|| data.get_uid().to_owned()),
             data,
             properties: cal.properties,
             ics,
@@ -220,20 +263,19 @@ impl CalendarObject {
     }
 
     #[must_use]
-    pub fn get_id(&self) -> &str {
+    pub fn get_uid(&self) -> &str {
-        match &self.data {
+        self.data.get_uid()
-            // We've made sure before that the first component exists and all components share the
-            // same UID
-            CalendarObjectComponent::Todo(todo, _) => todo.get_uid(),
-            CalendarObjectComponent::Event(event, _) => event.event.get_uid(),
-            CalendarObjectComponent::Journal(journal, _) => journal.get_uid(),
     }
+
+    #[must_use]
+    pub fn get_id(&self) -> &str {
+        &self.id
     }
 
     #[must_use]
     pub fn get_etag(&self) -> String {
         let mut hasher = Sha256::new();
-        hasher.update(self.get_id());
+        hasher.update(self.get_uid());
         hasher.update(self.get_ics());
         format!("\"{:x}\"", hasher.finalize())
     }
@@ -254,31 +296,11 @@ impl CalendarObject {
     }
 
     pub fn get_first_occurence(&self) -> Result<Option<CalDateTime>, Error> {
-        match &self.data {
+        self.data.get_first_occurence()
-            CalendarObjectComponent::Event(main_event, overrides) => Ok(overrides
-                .iter()
-                .chain(std::iter::once(main_event))
-                .map(super::event::EventObject::get_dtstart)
-                .collect::<Result<Vec<_>, _>>()?
-                .into_iter()
-                .flatten()
-                .min()),
-            _ => Ok(None),
-        }
     }
 
     pub fn get_last_occurence(&self) -> Result<Option<CalDateTime>, Error> {
-        match &self.data {
+        self.data.get_last_occurence()
-            CalendarObjectComponent::Event(main_event, overrides) => Ok(overrides
-                .iter()
-                .chain(std::iter::once(main_event))
-                .map(super::event::EventObject::get_last_occurence)
-                .collect::<Result<Vec<_>, _>>()?
-                .into_iter()
-                .flatten()
-                .max()),
-            _ => Ok(None),
-        }
     }
 
     pub fn expand_recurrence(
@@ -299,4 +321,11 @@ impl CalendarObject {
             _ => Ok(self.get_ics().to_string()),
         }
     }
+
+    #[must_use]
+    pub fn get_property(&self, name: &str) -> Option<&Property> {
+        self.properties
+            .iter()
+            .find(|property| property.name == name)
+    }
 }

crates/ical/src/timestamp.rs

@@ -13,7 +13,7 @@ const LOCAL_DATE_TIME: &str = "%Y%m%dT%H%M%S";
 const UTC_DATE_TIME: &str = "%Y%m%dT%H%M%SZ";
 pub const LOCAL_DATE: &str = "%Y%m%d";
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug, thiserror::Error, PartialEq, Eq)]
 pub enum CalDateTimeError {
     #[error(
         "Timezone has X-LIC-LOCATION property to specify a timezone from the Olson database, however its value {0} is invalid"

crates/ical/tests/test_cal_object.rs

@@ -25,6 +25,6 @@ END:VCALENDAR
 
 #[test]
 fn parse_calendar_object() {
-    let object = CalendarObject::from_ics(MULTI_VEVENT.to_string()).unwrap();
+    let object = CalendarObject::from_ics(MULTI_VEVENT.to_string(), None).unwrap();
     object.expand_recurrence(None, None).unwrap();
 }

crates/oidc/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "rustical_oidc"
 version.workspace = true
+rust-version.workspace = true
 edition.workspace = true
 description.workspace = true
 repository.workspace = true
@@ -14,7 +15,7 @@ reqwest.workspace = true
 thiserror.workspace = true
 async-trait.workspace = true
 axum.workspace = true
-tower-sessions = "0.14"
+tower-sessions.workspace = true
 axum-extra.workspace = true
 headers.workspace = true
 tracing.workspace = true

crates/store/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "rustical_store"
 version.workspace = true
+rust-version.workspace = true
 edition.workspace = true
 description.workspace = true
 repository.workspace = true
@@ -8,16 +9,16 @@ license.workspace = true
 publish = false
 
 [dependencies]
-anyhow = { workspace = true }
+anyhow.workspace = true
-async-trait = { workspace = true }
+async-trait.workspace = true
-serde = { workspace = true }
+serde.workspace = true
-sha2 = { workspace = true }
+sha2.workspace = true
-ical = { workspace = true }
+ical.workspace = true
-chrono = { workspace = true }
+chrono.workspace = true
-regex = { workspace = true }
+regex.workspace = true
-thiserror = { workspace = true }
+thiserror.workspace = true
-tracing = { workspace = true }
+tracing.workspace = true
-chrono-tz = { workspace = true }
+chrono-tz.workspace = true
 derive_more = { workspace = true, features = ["as_ref"] }
 rustical_xml.workspace = true
 tokio.workspace = true
@@ -34,7 +35,7 @@ tower-sessions.workspace = true
 vtimezones-rs.workspace = true
 
 [dev-dependencies]
-rstest = { workspace = true }
+rstest.workspace = true
-rstest_reuse = { workspace = true }
+rstest_reuse.workspace = true
 rustical_store_sqlite.workspace = true
 tokio.workspace = true

crates/store/src/addressbook.rs

@@ -2,7 +2,7 @@ use crate::synctoken::format_synctoken;
 use chrono::NaiveDateTime;
 use serde::Serialize;
 
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
 pub struct Addressbook {
     pub id: String,
     pub principal: String,

crates/store/src/calendar.rs

@@ -1,11 +1,10 @@
-use std::str::FromStr;
-
 use crate::synctoken::format_synctoken;
 use chrono::NaiveDateTime;
 use rustical_ical::CalendarObjectType;
 use serde::{Deserialize, Serialize};
+use std::str::FromStr;
 
-#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+#[derive(Debug, Default, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct CalendarMetadata {
     // Attributes that may be outsourced
     pub displayname: Option<String>,
@@ -14,7 +13,7 @@ pub struct CalendarMetadata {
     pub color: Option<String>,
 }
 
-#[derive(Debug, Default, Clone, Serialize, Deserialize)]
+#[derive(Debug, Default, Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct Calendar {
     // Attributes that may be outsourced
     #[serde(flatten)]

crates/store/src/calendar_store.rs

@@ -3,7 +3,7 @@ use async_trait::async_trait;
 use chrono::NaiveDate;
 use rustical_ical::CalendarObject;
 
-#[derive(Default, Debug, Clone)]
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
 pub struct CalendarQuery {
     pub time_start: Option<NaiveDate>,
     pub time_end: Option<NaiveDate>,
@@ -98,5 +98,6 @@ pub trait CalendarStore: Send + Sync + 'static {
         object_id: &str,
     ) -> Result<(), Error>;
 
+    // read_only refers to objects, metadata may still be updated
     fn is_read_only(&self, cal_id: &str) -> bool;
 }

crates/store/src/contact_birthday_store.rs

@@ -1,209 +0,0 @@
-use crate::{
-    Addressbook, AddressbookStore, Calendar, CalendarStore, Error, calendar::CalendarMetadata,
-    combined_calendar_store::PrefixedCalendarStore,
-};
-use async_trait::async_trait;
-use derive_more::derive::Constructor;
-use rustical_ical::{AddressObject, CalendarObject, CalendarObjectType};
-use sha2::{Digest, Sha256};
-use std::{collections::HashMap, sync::Arc};
-
-pub const BIRTHDAYS_PREFIX: &str = "_birthdays_";
-
-#[derive(Constructor, Clone)]
-pub struct ContactBirthdayStore<AS: AddressbookStore>(Arc<AS>);
-
-impl<AS: AddressbookStore> PrefixedCalendarStore for ContactBirthdayStore<AS> {
-    const PREFIX: &'static str = BIRTHDAYS_PREFIX;
-}
-
-fn birthday_calendar(addressbook: Addressbook) -> Calendar {
-    Calendar {
-        principal: addressbook.principal,
-        id: format!("{}{}", BIRTHDAYS_PREFIX, addressbook.id),
-        meta: CalendarMetadata {
-            displayname: addressbook
-                .displayname
-                .map(|name| format!("{name} birthdays")),
-            order: 0,
-            description: None,
-            color: None,
-        },
-        timezone_id: None,
-        deleted_at: addressbook.deleted_at,
-        synctoken: addressbook.synctoken,
-        subscription_url: None,
-        push_topic: {
-            let mut hasher = Sha256::new();
-            hasher.update("birthdays");
-            hasher.update(addressbook.push_topic);
-            format!("{:x}", hasher.finalize())
-        },
-        components: vec![CalendarObjectType::Event],
-    }
-}
-
-/// Objects are all prefixed with `BIRTHDAYS_PREFIX`
-#[async_trait]
-impl<AS: AddressbookStore> CalendarStore for ContactBirthdayStore<AS> {
-    async fn get_calendar(
-        &self,
-        principal: &str,
-        id: &str,
-        show_deleted: bool,
-    ) -> Result<Calendar, Error> {
-        let id = id.strip_prefix(BIRTHDAYS_PREFIX).ok_or(Error::NotFound)?;
-        let addressbook = self.0.get_addressbook(principal, id, show_deleted).await?;
-        Ok(birthday_calendar(addressbook))
-    }
-
-    async fn get_calendars(&self, principal: &str) -> Result<Vec<Calendar>, Error> {
-        let addressbooks = self.0.get_addressbooks(principal).await?;
-        Ok(addressbooks.into_iter().map(birthday_calendar).collect())
-    }
-
-    async fn get_deleted_calendars(&self, principal: &str) -> Result<Vec<Calendar>, Error> {
-        let addressbooks = self.0.get_deleted_addressbooks(principal).await?;
-        Ok(addressbooks.into_iter().map(birthday_calendar).collect())
-    }
-
-    async fn update_calendar(
-        &self,
-        _principal: String,
-        _id: String,
-        _calendar: Calendar,
-    ) -> Result<(), Error> {
-        Err(Error::ReadOnly)
-    }
-
-    async fn insert_calendar(&self, _calendar: Calendar) -> Result<(), Error> {
-        Err(Error::ReadOnly)
-    }
-    async fn delete_calendar(
-        &self,
-        _principal: &str,
-        _name: &str,
-        _use_trashbin: bool,
-    ) -> Result<(), Error> {
-        Err(Error::ReadOnly)
-    }
-
-    async fn restore_calendar(&self, _principal: &str, _name: &str) -> Result<(), Error> {
-        Err(Error::ReadOnly)
-    }
-
-    async fn import_calendar(
-        &self,
-        _calendar: Calendar,
-        _objects: Vec<CalendarObject>,
-        _merge_existing: bool,
-    ) -> Result<(), Error> {
-        Err(Error::ReadOnly)
-    }
-
-    async fn sync_changes(
-        &self,
-        principal: &str,
-        cal_id: &str,
-        synctoken: i64,
-    ) -> Result<(Vec<CalendarObject>, Vec<String>, i64), Error> {
-        let cal_id = cal_id
-            .strip_prefix(BIRTHDAYS_PREFIX)
-            .ok_or(Error::NotFound)?;
-        let (objects, deleted_objects, new_synctoken) =
-            self.0.sync_changes(principal, cal_id, synctoken).await?;
-        let objects: Result<Vec<Option<CalendarObject>>, rustical_ical::Error> = objects
-            .iter()
-            .map(AddressObject::get_birthday_object)
-            .collect();
-        let objects = objects?.into_iter().flatten().collect();
-
-        Ok((objects, deleted_objects, new_synctoken))
-    }
-
-    async fn calendar_metadata(
-        &self,
-        principal: &str,
-        cal_id: &str,
-    ) -> Result<crate::CollectionMetadata, Error> {
-        let cal_id = cal_id
-            .strip_prefix(BIRTHDAYS_PREFIX)
-            .ok_or(Error::NotFound)?;
-        self.0.addressbook_metadata(principal, cal_id).await
-    }
-
-    async fn get_objects(
-        &self,
-        principal: &str,
-        cal_id: &str,
-    ) -> Result<Vec<CalendarObject>, Error> {
-        let cal_id = cal_id
-            .strip_prefix(BIRTHDAYS_PREFIX)
-            .ok_or(Error::NotFound)?;
-        let objects: Result<Vec<HashMap<&'static str, CalendarObject>>, rustical_ical::Error> =
-            self.0
-                .get_objects(principal, cal_id)
-                .await?
-                .iter()
-                .map(AddressObject::get_significant_dates)
-                .collect();
-        let objects = objects?
-            .into_iter()
-            .flat_map(HashMap::into_values)
-            .collect();
-
-        Ok(objects)
-    }
-
-    async fn get_object(
-        &self,
-        principal: &str,
-        cal_id: &str,
-        object_id: &str,
-        show_deleted: bool,
-    ) -> Result<CalendarObject, Error> {
-        let cal_id = cal_id
-            .strip_prefix(BIRTHDAYS_PREFIX)
-            .ok_or(Error::NotFound)?;
-        let (addressobject_id, date_type) = object_id.rsplit_once('-').ok_or(Error::NotFound)?;
-        self.0
-            .get_object(principal, cal_id, addressobject_id, show_deleted)
-            .await?
-            .get_significant_dates()?
-            .remove(date_type)
-            .ok_or(Error::NotFound)
-    }
-
-    async fn put_object(
-        &self,
-        _principal: String,
-        _cal_id: String,
-        _object: CalendarObject,
-        _overwrite: bool,
-    ) -> Result<(), Error> {
-        Err(Error::ReadOnly)
-    }
-
-    async fn delete_object(
-        &self,
-        _principal: &str,
-        _cal_id: &str,
-        _object_id: &str,
-        _use_trashbin: bool,
-    ) -> Result<(), Error> {
-        Err(Error::ReadOnly)
-    }
-
-    async fn restore_object(
-        &self,
-        _principal: &str,
-        _cal_id: &str,
-        _object_id: &str,
-    ) -> Result<(), Error> {
-        Err(Error::ReadOnly)
-    }
-
-    fn is_read_only(&self, _cal_id: &str) -> bool {
-        true
-    }
-}

crates/store/src/error.rs

@@ -41,6 +41,11 @@ impl Error {
             _ => StatusCode::INTERNAL_SERVER_ERROR,
         }
     }
+
+    #[must_use]
+    pub const fn is_not_found(&self) -> bool {
+        matches!(self, Self::NotFound)
+    }
 }
 
 impl IntoResponse for Error {

crates/store/src/lib.rs

@@ -7,7 +7,6 @@ pub use error::Error;
 pub mod auth;
 mod calendar;
 mod combined_calendar_store;
-mod contact_birthday_store;
 mod secret;
 mod subscription_store;
 pub mod synctoken;
@@ -17,8 +16,7 @@ pub mod tests;
 
 pub use addressbook_store::AddressbookStore;
 pub use calendar_store::CalendarStore;
-pub use combined_calendar_store::CombinedCalendarStore;
+pub use combined_calendar_store::{CombinedCalendarStore, PrefixedCalendarStore};
-pub use contact_birthday_store::ContactBirthdayStore;
 pub use secret::Secret;
 pub use subscription_store::*;
 

crates/store_sqlite/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "rustical_store_sqlite"
 version.workspace = true
+rust-version.workspace = true
 edition.workspace = true
 description.workspace = true
 repository.workspace = true
@@ -15,12 +16,12 @@ rstest.workspace = true
 
 [dependencies]
 tokio.workspace = true
-rustical_store = { workspace = true }
+rustical_store.workspace = true
-async-trait = { workspace = true }
+async-trait.workspace = true
-serde = { workspace = true }
+serde.workspace = true
-sqlx = { workspace = true }
+sqlx.workspace = true
-thiserror = { workspace = true }
+thiserror.workspace = true
-tracing = { workspace = true }
+tracing.workspace = true
 derive_more.workspace = true
 chrono.workspace = true
 password-auth.workspace = true
@@ -29,3 +30,4 @@ uuid.workspace = true
 pbkdf2.workspace = true
 rustical_ical.workspace = true
 rstest = { workspace = true, optional = true }
+sha2.workspace = true

crates/store_sqlite/migrations/20251101181540_add_calendar_uid.down.sql

@@ -0,0 +1,47 @@
+DROP INDEX idx_calobjs_uid;
+ALTER TABLE calendarobjects RENAME TO calendarobjects_old;
+
+CREATE TABLE calendarobjects (
+    principal TEXT NOT NULL,
+    cal_id TEXT NOT NULL,
+    id TEXT NOT NULL, -- filename
+    ics TEXT NOT NULL,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    deleted_at DATETIME,
+
+    -- For more efficient calendar-queries
+    first_occurence DATE,
+    last_occurence DATE,
+    etag TEXT,
+    object_type INTEGER NOT NULL,  -- VEVENT(0)/VTODO(1)/VJOURNAL(2)
+
+    CONSTRAINT pk_calendarobject_id PRIMARY KEY (principal, cal_id, id),
+    CONSTRAINT fk_calendarobject_calendar FOREIGN KEY (principal, cal_id)
+    REFERENCES calendars (principal, id) ON DELETE CASCADE
+);
+
+INSERT INTO calendarobjects (
+    principal,
+    cal_id,
+    id,
+    ics,
+    updated_at,
+    deleted_at,
+    first_occurence,
+    last_occurence,
+    etag,
+    object_type
+) SELECT
+    principal,
+    cal_id,
+    id,
+    ics,
+    updated_at,
+    deleted_at,
+    first_occurence,
+    last_occurence,
+    etag,
+    object_type
+FROM calendarobjects_old;
+
+DROP TABLE calendarobjects_old;

crates/store_sqlite/migrations/20251101181540_add_calendar_uid.up.sql

@@ -0,0 +1,53 @@
+-- Adds the column "uid" and populates it with data from "id"
+ALTER TABLE calendarobjects RENAME TO calendarobjects_old;
+
+CREATE TABLE calendarobjects (
+    principal TEXT NOT NULL,
+    cal_id TEXT NOT NULL,
+    id TEXT NOT NULL, -- filename
+    "uid" TEXT NOT NULL, -- global identifier
+    ics TEXT NOT NULL,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    deleted_at DATETIME,
+
+    -- For more efficient calendar-queries
+    first_occurence DATE,
+    last_occurence DATE,
+    etag TEXT,
+    object_type INTEGER NOT NULL,  -- VEVENT(0)/VTODO(1)/VJOURNAL(2)
+
+    CONSTRAINT pk_calendarobject_id PRIMARY KEY (principal, cal_id, id),
+    CONSTRAINT uq_calendarobject_uid UNIQUE (principal, cal_id, "uid"),
+    CONSTRAINT fk_calendarobject_calendar FOREIGN KEY (principal, cal_id)
+    REFERENCES calendars (principal, id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_calobjs_uid ON calendarobjects (principal, cal_id, "uid");
+
+INSERT INTO calendarobjects (
+    principal,
+    cal_id,
+    id,
+    "uid",
+    ics,
+    updated_at,
+    deleted_at,
+    first_occurence,
+    last_occurence,
+    etag,
+    object_type
+) SELECT
+    principal,
+    cal_id,
+    id,
+    id AS "uid",
+    ics,
+    updated_at,
+    deleted_at,
+    first_occurence,
+    last_occurence,
+    etag,
+    object_type
+FROM calendarobjects_old;
+
+DROP TABLE calendarobjects_old;

crates/store_sqlite/migrations/20251102192200_birthday_calendars.down.sql

@@ -0,0 +1 @@
+DROP TABLE birthday_calendars;

crates/store_sqlite/migrations/20251102192200_birthday_calendars.up.sql

@@ -0,0 +1,26 @@
+CREATE TABLE birthday_calendars (
+    principal TEXT NOT NULL,
+    id TEXT NOT NULL,
+    displayname TEXT,
+    description TEXT,
+    "order" INT DEFAULT 0 NOT NULL,
+    color TEXT,
+    timezone_id TEXT,
+    deleted_at DATETIME,
+    push_topic TEXT NOT NULL,
+    PRIMARY KEY (principal, id),
+    CONSTRAINT fk_birthdays_addressbooks FOREIGN KEY (principal, id)
+    REFERENCES addressbooks (principal, id) ON DELETE CASCADE
+    -- birthday calendar stores no meaningful data so we can cascade
+);
+
+INSERT INTO birthday_calendars
+(principal, id, displayname, deleted_at, push_topic)
+SELECT
+    principal,
+    id,
+    displayname || ' birthdays' AS displayname,
+    deleted_at,
+    push_topic || substr(printf('%d', random()), -4) AS push_topic
+    -- jank suffix to ensure that new push_topic is different :D
+FROM addressbooks;

crates/store_sqlite/src/addressbook_store/birthday_calendar.rs

@@ -0,0 +1,431 @@
+use crate::addressbook_store::SqliteAddressbookStore;
+use async_trait::async_trait;
+use chrono::NaiveDateTime;
+use rustical_ical::{AddressObject, CalendarObject, CalendarObjectType};
+use rustical_store::{
+    Addressbook, AddressbookStore, Calendar, CalendarMetadata, CalendarStore, CollectionMetadata,
+    Error, PrefixedCalendarStore,
+};
+use sha2::{Digest, Sha256};
+use sqlx::{Executor, Sqlite};
+use std::collections::HashMap;
+use tracing::instrument;
+
+pub const BIRTHDAYS_PREFIX: &str = "_birthdays_";
+
+struct BirthdayCalendarJoinRow {
+    principal: String,
+    id: String,
+    displayname: Option<String>,
+    description: Option<String>,
+    order: i64,
+    color: Option<String>,
+    timezone_id: Option<String>,
+    deleted_at: Option<NaiveDateTime>,
+    push_topic: String,
+
+    addr_synctoken: i64,
+}
+
+impl From<BirthdayCalendarJoinRow> for Calendar {
+    fn from(value: BirthdayCalendarJoinRow) -> Self {
+        Self {
+            principal: value.principal,
+            id: format!("{}{}", BIRTHDAYS_PREFIX, value.id),
+            meta: CalendarMetadata {
+                displayname: value.displayname,
+                order: value.order,
+                description: value.description,
+                color: value.color,
+            },
+            deleted_at: value.deleted_at,
+            components: vec![CalendarObjectType::Event],
+            timezone_id: value.timezone_id,
+            synctoken: value.addr_synctoken,
+            subscription_url: None,
+            push_topic: value.push_topic,
+        }
+    }
+}
+
+impl PrefixedCalendarStore for SqliteAddressbookStore {
+    const PREFIX: &'static str = BIRTHDAYS_PREFIX;
+}
+
+impl SqliteAddressbookStore {
+    #[instrument]
+    pub async fn _get_birthday_calendar<'e, E: Executor<'e, Database = Sqlite>>(
+        executor: E,
+        principal: &str,
+        id: &str,
+        show_deleted: bool,
+    ) -> Result<Calendar, Error> {
+        let cal = sqlx::query_as!(
+            BirthdayCalendarJoinRow,
+            r#"SELECT principal, id, displayname, description, "order", color, timezone_id, deleted_at, addr_synctoken, push_topic
+                FROM birthday_calendars
+                INNER JOIN (
+                    SELECT principal AS addr_principal,
+                        id AS addr_id,
+                        synctoken AS addr_synctoken
+                    FROM addressbooks
+                    ) ON (principal, id) = (addr_principal, addr_id)
+                WHERE (principal, id) = (?, ?)
+                AND ((deleted_at IS NULL) OR ?)
+            "#,
+            principal,
+            id,
+            show_deleted
+        )
+        .fetch_one(executor)
+        .await
+        .map_err(crate::Error::from)?;
+        Ok(cal.into())
+    }
+
+    #[instrument]
+    pub async fn _get_birthday_calendars<'e, E: Executor<'e, Database = Sqlite>>(
+        executor: E,
+        principal: &str,
+        deleted: bool,
+    ) -> Result<Vec<Calendar>, Error> {
+        Ok(
+        sqlx::query_as!(
+            BirthdayCalendarJoinRow,
+            r#"SELECT principal, id, displayname, description, "order", color, timezone_id, deleted_at, addr_synctoken, push_topic
+                FROM birthday_calendars
+                INNER JOIN (
+                    SELECT principal AS addr_principal,
+                        id AS addr_id,
+                        synctoken AS addr_synctoken
+                    FROM addressbooks
+                    ) ON (principal, id) = (addr_principal, addr_id)
+                WHERE principal = ?
+                AND (
+                    (deleted_at IS NULL AND NOT ?) -- not deleted, want not deleted
+                    OR (deleted_at IS NOT NULL AND ?) -- deleted, want deleted
+                )
+            "#,
+            principal,
+            deleted,
+            deleted
+        )
+        .fetch_all(executor)
+        .await
+        .map_err(crate::Error::from).map(|cals| cals.into_iter().map(BirthdayCalendarJoinRow::into).collect())?)
+    }
+
+    #[must_use]
+    pub fn default_birthday_calendar(addressbook: Addressbook) -> Calendar {
+        let birthday_name = addressbook
+            .displayname
+            .as_ref()
+            .map(|name| format!("{name} birthdays"));
+        let birthday_push_topic = {
+            let mut hasher = Sha256::new();
+            hasher.update("birthdays");
+            hasher.update(&addressbook.push_topic);
+            format!("{:x}", hasher.finalize())
+        };
+        Calendar {
+            principal: addressbook.principal,
+            meta: CalendarMetadata {
+                displayname: birthday_name,
+                order: 0,
+                description: None,
+                color: None,
+            },
+            id: format!("{}{}", Self::PREFIX, addressbook.id),
+            components: vec![CalendarObjectType::Event],
+            timezone_id: None,
+            deleted_at: None,
+            synctoken: Default::default(),
+            subscription_url: None,
+            push_topic: birthday_push_topic,
+        }
+    }
+
+    #[instrument]
+    pub async fn _insert_birthday_calendar<'e, E: Executor<'e, Database = Sqlite>>(
+        executor: E,
+        calendar: &Calendar,
+    ) -> Result<(), rustical_store::Error> {
+        let id = calendar
+            .id
+            .strip_prefix(BIRTHDAYS_PREFIX)
+            .ok_or(Error::NotFound)?;
+
+        sqlx::query!(
+            r#"INSERT INTO birthday_calendars (principal, id, displayname, description, "order", color, push_topic)
+                VALUES (?, ?, ?, ?, ?, ?, ?)"#,
+            calendar.principal,
+            id,
+            calendar.meta.displayname,
+            calendar.meta.description,
+            calendar.meta.order,
+            calendar.meta.color,
+            calendar.push_topic,
+        )
+        .execute(executor)
+        .await
+        .map_err(crate::Error::from)?;
+        Ok(())
+    }
+
+    async fn _delete_birthday_calendar<'e, E: Executor<'e, Database = Sqlite>>(
+        executor: E,
+        principal: &str,
+        id: &str,
+        use_trashbin: bool,
+    ) -> Result<(), Error> {
+        if use_trashbin {
+            sqlx::query!(
+                r#"UPDATE birthday_calendars SET deleted_at = datetime() WHERE (principal, id) = (?, ?)"#,
+                principal,
+                id
+            )
+            .execute(executor)
+            .await
+            .map_err(crate::Error::from)?
+        } else {
+            sqlx::query!(
+                r#"DELETE FROM birthday_calendars WHERE (principal, id) = (?, ?)"#,
+                principal,
+                id
+            )
+            .execute(executor)
+            .await
+            .map_err(crate::Error::from)?
+        };
+        Ok(())
+    }
+
+    async fn _restore_birthday_calendar<'e, E: Executor<'e, Database = Sqlite>>(
+        executor: E,
+        principal: &str,
+        id: &str,
+    ) -> Result<(), Error> {
+        sqlx::query!(
+            r"UPDATE birthday_calendars SET deleted_at = NULL WHERE (principal, id) = (?, ?)",
+            principal,
+            id
+        )
+        .execute(executor)
+        .await
+        .map_err(crate::Error::from)?;
+        Ok(())
+    }
+
+    #[instrument]
+    async fn _update_birthday_calendar<'e, E: Executor<'e, Database = Sqlite>>(
+        executor: E,
+        principal: &str,
+        calendar: &Calendar,
+    ) -> Result<(), Error> {
+        let result = sqlx::query!(
+            r#"UPDATE birthday_calendars SET principal = ?, id = ?, displayname = ?, description = ?, "order" = ?, color = ?, timezone_id = ?, push_topic = ?
+                WHERE (principal, id) = (?, ?)"#,
+            calendar.principal,
+            calendar.id,
+            calendar.meta.displayname,
+            calendar.meta.description,
+            calendar.meta.order,
+            calendar.meta.color,
+            calendar.timezone_id,
+            calendar.push_topic,
+            principal,
+            calendar.id,
+        ).execute(executor).await.map_err(crate::Error::from)?;
+        if result.rows_affected() == 0 {
+            return Err(rustical_store::Error::NotFound);
+        }
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl CalendarStore for SqliteAddressbookStore {
+    #[instrument]
+    async fn get_calendar(
+        &self,
+        principal: &str,
+        id: &str,
+        show_deleted: bool,
+    ) -> Result<Calendar, Error> {
+        let id = id.strip_prefix(BIRTHDAYS_PREFIX).ok_or(Error::NotFound)?;
+        Self::_get_birthday_calendar(&self.db, principal, id, show_deleted).await
+    }
+
+    #[instrument]
+    async fn get_calendars(&self, principal: &str) -> Result<Vec<Calendar>, Error> {
+        Self::_get_birthday_calendars(&self.db, principal, false).await
+    }
+
+    #[instrument]
+    async fn get_deleted_calendars(&self, principal: &str) -> Result<Vec<Calendar>, Error> {
+        Self::_get_birthday_calendars(&self.db, principal, true).await
+    }
+
+    #[instrument]
+    async fn update_calendar(
+        &self,
+        principal: String,
+        id: String,
+        mut calendar: Calendar,
+    ) -> Result<(), Error> {
+        assert_eq!(id, calendar.id);
+        calendar.id = calendar
+            .id
+            .strip_prefix(BIRTHDAYS_PREFIX)
+            .ok_or(Error::NotFound)?
+            .to_string();
+        Self::_update_birthday_calendar(&self.db, &principal, &calendar).await
+    }
+
+    #[instrument]
+    async fn insert_calendar(&self, calendar: Calendar) -> Result<(), Error> {
+        Self::_insert_birthday_calendar(&self.db, &calendar).await
+    }
+
+    #[instrument]
+    async fn delete_calendar(
+        &self,
+        principal: &str,
+        id: &str,
+        use_trashbin: bool,
+    ) -> Result<(), Error> {
+        let Some(id) = id.strip_prefix(BIRTHDAYS_PREFIX) else {
+            return Ok(());
+        };
+        Self::_delete_birthday_calendar(&self.db, principal, id, use_trashbin).await
+    }
+
+    #[instrument]
+    async fn restore_calendar(&self, principal: &str, id: &str) -> Result<(), Error> {
+        let Some(id) = id.strip_prefix(BIRTHDAYS_PREFIX) else {
+            return Err(Error::NotFound);
+        };
+        Self::_restore_birthday_calendar(&self.db, principal, id).await
+    }
+
+    #[instrument]
+    async fn import_calendar(
+        &self,
+        _calendar: Calendar,
+        _objects: Vec<CalendarObject>,
+        _merge_existing: bool,
+    ) -> Result<(), Error> {
+        Err(Error::ReadOnly)
+    }
+
+    #[instrument]
+    async fn sync_changes(
+        &self,
+        principal: &str,
+        cal_id: &str,
+        synctoken: i64,
+    ) -> Result<(Vec<CalendarObject>, Vec<String>, i64), Error> {
+        let cal_id = cal_id
+            .strip_prefix(BIRTHDAYS_PREFIX)
+            .ok_or(Error::NotFound)?;
+        let (objects, deleted_objects, new_synctoken) =
+            AddressbookStore::sync_changes(self, principal, cal_id, synctoken).await?;
+        let objects: Result<Vec<Option<CalendarObject>>, rustical_ical::Error> = objects
+            .iter()
+            .map(AddressObject::get_birthday_object)
+            .collect();
+        let objects = objects?.into_iter().flatten().collect();
+
+        Ok((objects, deleted_objects, new_synctoken))
+    }
+
+    #[instrument]
+    async fn calendar_metadata(
+        &self,
+        principal: &str,
+        cal_id: &str,
+    ) -> Result<CollectionMetadata, Error> {
+        let cal_id = cal_id
+            .strip_prefix(BIRTHDAYS_PREFIX)
+            .ok_or(Error::NotFound)?;
+        self.addressbook_metadata(principal, cal_id).await
+    }
+
+    #[instrument]
+    async fn get_objects(
+        &self,
+        principal: &str,
+        cal_id: &str,
+    ) -> Result<Vec<CalendarObject>, Error> {
+        let cal_id = cal_id
+            .strip_prefix(BIRTHDAYS_PREFIX)
+            .ok_or(Error::NotFound)?;
+        let objects: Result<Vec<HashMap<&'static str, CalendarObject>>, rustical_ical::Error> =
+            AddressbookStore::get_objects(self, principal, cal_id)
+                .await?
+                .iter()
+                .map(AddressObject::get_significant_dates)
+                .collect();
+        let objects = objects?
+            .into_iter()
+            .flat_map(HashMap::into_values)
+            .collect();
+
+        Ok(objects)
+    }
+
+    #[instrument]
+    async fn get_object(
+        &self,
+        principal: &str,
+        cal_id: &str,
+        object_id: &str,
+        show_deleted: bool,
+    ) -> Result<CalendarObject, Error> {
+        let cal_id = cal_id
+            .strip_prefix(BIRTHDAYS_PREFIX)
+            .ok_or(Error::NotFound)?;
+        let (addressobject_id, date_type) = object_id.rsplit_once('-').ok_or(Error::NotFound)?;
+        AddressbookStore::get_object(self, principal, cal_id, addressobject_id, show_deleted)
+            .await?
+            .get_significant_dates()?
+            .remove(date_type)
+            .ok_or(Error::NotFound)
+    }
+
+    #[instrument]
+    async fn put_object(
+        &self,
+        _principal: String,
+        _cal_id: String,
+        _object: CalendarObject,
+        _overwrite: bool,
+    ) -> Result<(), Error> {
+        Err(Error::ReadOnly)
+    }
+
+    #[instrument]
+    async fn delete_object(
+        &self,
+        _principal: &str,
+        _cal_id: &str,
+        _object_id: &str,
+        _use_trashbin: bool,
+    ) -> Result<(), Error> {
+        Err(Error::ReadOnly)
+    }
+
+    #[instrument]
+    async fn restore_object(
+        &self,
+        _principal: &str,
+        _cal_id: &str,
+        _object_id: &str,
+    ) -> Result<(), Error> {
+        Err(Error::ReadOnly)
+    }
+
+    fn is_read_only(&self, _cal_id: &str) -> bool {
+        true
+    }
+}

crates/store_sqlite/src/addressbook_store/mod.rs

@@ -1,4 +1,5 @@
 use super::ChangeOperation;
+use crate::BEGIN_IMMEDIATE;
 use async_trait::async_trait;
 use derive_more::derive::Constructor;
 use rustical_ical::AddressObject;
@@ -8,7 +9,9 @@ use rustical_store::{
 };
 use sqlx::{Acquire, Executor, Sqlite, SqlitePool, Transaction};
 use tokio::sync::mpsc::Sender;
-use tracing::{error, instrument};
+use tracing::{error, instrument, warn};
+
+pub mod birthday_calendar;
 
 #[derive(Debug, Clone)]
 struct AddressObjectRow {
@@ -31,6 +34,60 @@ pub struct SqliteAddressbookStore {
 }
 
 impl SqliteAddressbookStore {
+    // Commit "orphaned" objects to the changelog table
+    pub async fn repair_orphans(&self) -> Result<(), Error> {
+        struct Row {
+            principal: String,
+            addressbook_id: String,
+            id: String,
+            deleted: bool,
+        }
+
+        let mut tx = self
+            .db
+            .begin_with(BEGIN_IMMEDIATE)
+            .await
+            .map_err(crate::Error::from)?;
+
+        let rows = sqlx::query_as!(
+            Row,
+            r#"
+                SELECT principal, addressbook_id, id, (deleted_at IS NOT NULL) AS "deleted: bool"
+                    FROM addressobjects
+                    WHERE (principal, addressbook_id, id) NOT IN (
+                        SELECT DISTINCT principal, addressbook_id, object_id FROM addressobjectchangelog
+                    )
+                ;
+                "#,
+        )
+        .fetch_all(&mut *tx)
+        .await
+        .map_err(crate::Error::from)?;
+
+        for row in rows {
+            let operation = if row.deleted {
+                ChangeOperation::Delete
+            } else {
+                ChangeOperation::Add
+            };
+            warn!(
+                "Commiting orphaned addressbook object ({},{},{}), deleted={}",
+                &row.principal, &row.addressbook_id, &row.id, &row.deleted
+            );
+            log_object_operation(
+                &mut tx,
+                &row.principal,
+                &row.addressbook_id,
+                &row.id,
+                operation,
+            )
+            .await?;
+        }
+        tx.commit().await.map_err(crate::Error::from)?;
+
+        Ok(())
+    }
+
     async fn _get_addressbook<'e, E: Executor<'e, Database = Sqlite>>(
         executor: E,
         principal: &str,
@@ -89,9 +146,9 @@ impl SqliteAddressbookStore {
 
     async fn _update_addressbook<'e, E: Executor<'e, Database = Sqlite>>(
         executor: E,
-        principal: String,
+        principal: &str,
-        id: String,
+        id: &str,
-        addressbook: Addressbook,
+        addressbook: &Addressbook,
     ) -> Result<(), rustical_store::Error> {
         let result = sqlx::query!(
             r#"UPDATE addressbooks SET principal = ?, id = ?, displayname = ?, description = ?, push_topic = ?
@@ -115,7 +172,7 @@ impl SqliteAddressbookStore {
 
     async fn _insert_addressbook<'e, E: Executor<'e, Database = Sqlite>>(
         executor: E,
-        addressbook: Addressbook,
+        addressbook: &Addressbook,
     ) -> Result<(), rustical_store::Error> {
         sqlx::query!(
             r#"INSERT INTO addressbooks (principal, id, displayname, description, push_topic)
@@ -282,9 +339,9 @@ impl SqliteAddressbookStore {
 
     async fn _put_object<'e, E: Executor<'e, Database = Sqlite>>(
         executor: E,
-        principal: String,
+        principal: &str,
-        addressbook_id: String,
+        addressbook_id: &str,
-        object: AddressObject,
+        object: &AddressObject,
         overwrite: bool,
     ) -> Result<(), rustical_store::Error> {
         let (object_id, vcf) = (object.get_id(), object.get_vcf());
@@ -396,7 +453,7 @@ impl AddressbookStore for SqliteAddressbookStore {
         id: String,
         addressbook: Addressbook,
     ) -> Result<(), rustical_store::Error> {
-        Self::_update_addressbook(&self.db, principal, id, addressbook).await
+        Self::_update_addressbook(&self.db, &principal, &id, &addressbook).await
     }
 
     #[instrument]
@@ -404,7 +461,16 @@ impl AddressbookStore for SqliteAddressbookStore {
         &self,
         addressbook: Addressbook,
     ) -> Result<(), rustical_store::Error> {
-        Self::_insert_addressbook(&self.db, addressbook).await
+        let mut tx = self
+            .db
+            .begin_with(BEGIN_IMMEDIATE)
+            .await
+            .map_err(crate::Error::from)?;
+        Self::_insert_addressbook(&mut *tx, &addressbook).await?;
+        let birthday_cal = Self::default_birthday_calendar(addressbook);
+        Self::_insert_birthday_calendar(&mut *tx, &birthday_cal).await?;
+        tx.commit().await.map_err(crate::Error::from)?;
+        Ok(())
     }
 
     #[instrument]
@@ -414,7 +480,11 @@ impl AddressbookStore for SqliteAddressbookStore {
         addressbook_id: &str,
         use_trashbin: bool,
     ) -> Result<(), rustical_store::Error> {
-        let mut tx = self.db.begin().await.map_err(crate::Error::from)?;
+        let mut tx = self
+            .db
+            .begin_with(BEGIN_IMMEDIATE)
+            .await
+            .map_err(crate::Error::from)?;
 
         let addressbook =
             match Self::_get_addressbook(&mut *tx, principal, addressbook_id, use_trashbin).await {
@@ -508,18 +578,15 @@ impl AddressbookStore for SqliteAddressbookStore {
         object: AddressObject,
         overwrite: bool,
     ) -> Result<(), rustical_store::Error> {
-        let mut tx = self.db.begin().await.map_err(crate::Error::from)?;
+        let mut tx = self
+            .db
+            .begin_with(BEGIN_IMMEDIATE)
+            .await
+            .map_err(crate::Error::from)?;
 
         let object_id = object.get_id().to_owned();
 
-        Self::_put_object(
+        Self::_put_object(&mut *tx, &principal, &addressbook_id, &object, overwrite).await?;
-            &mut *tx,
-            principal.clone(),
-            addressbook_id.clone(),
-            object,
-            overwrite,
-        )
-        .await?;
 
         let sync_token = log_object_operation(
             &mut tx,
@@ -554,7 +621,11 @@ impl AddressbookStore for SqliteAddressbookStore {
         object_id: &str,
         use_trashbin: bool,
     ) -> Result<(), rustical_store::Error> {
-        let mut tx = self.db.begin().await.map_err(crate::Error::from)?;
+        let mut tx = self
+            .db
+            .begin_with(BEGIN_IMMEDIATE)
+            .await
+            .map_err(crate::Error::from)?;
 
         Self::_delete_object(&mut *tx, principal, addressbook_id, object_id, use_trashbin).await?;
 
@@ -589,7 +660,11 @@ impl AddressbookStore for SqliteAddressbookStore {
         addressbook_id: &str,
         object_id: &str,
     ) -> Result<(), rustical_store::Error> {
-        let mut tx = self.db.begin().await.map_err(crate::Error::from)?;
+        let mut tx = self
+            .db
+            .begin_with(BEGIN_IMMEDIATE)
+            .await
+            .map_err(crate::Error::from)?;
 
         Self::_restore_object(&mut *tx, principal, addressbook_id, object_id).await?;
 
@@ -611,7 +686,7 @@ impl AddressbookStore for SqliteAddressbookStore {
                 .await?
                 .push_topic,
         }) {
-            error!("Push notification about deleted addressbook failed: {err}");
+            error!("Push notification about restored addressbook object failed: {err}");
         }
 
         Ok(())
@@ -624,7 +699,11 @@ impl AddressbookStore for SqliteAddressbookStore {
         objects: Vec<AddressObject>,
         merge_existing: bool,
     ) -> Result<(), Error> {
-        let mut tx = self.db.begin().await.map_err(crate::Error::from)?;
+        let mut tx = self
+            .db
+            .begin_with(BEGIN_IMMEDIATE)
+            .await
+            .map_err(crate::Error::from)?;
 
         let existing =
             match Self::_get_addressbook(&mut *tx, &addressbook.principal, &addressbook.id, true)
@@ -638,21 +717,44 @@ impl AddressbookStore for SqliteAddressbookStore {
             return Err(Error::AlreadyExists);
         }
         if existing.is_none() {
-            Self::_insert_addressbook(&mut *tx, addressbook.clone()).await?;
+            Self::_insert_addressbook(&mut *tx, &addressbook).await?;
         }
 
+        let mut sync_token = None;
         for object in objects {
             Self::_put_object(
                 &mut *tx,
-                addressbook.principal.clone(),
+                &addressbook.principal,
-                addressbook.id.clone(),
+                &addressbook.id,
-                object,
+                &object,
                 false,
             )
             .await?;
+
+            sync_token = Some(
+                log_object_operation(
+                    &mut tx,
+                    &addressbook.principal,
+                    &addressbook.id,
+                    object.get_id(),
+                    ChangeOperation::Add,
+                )
+                .await?,
+            );
         }
 
         tx.commit().await.map_err(crate::Error::from)?;
+        if let Some(sync_token) = sync_token
+            && let Err(err) = self.sender.try_send(CollectionOperation {
+                data: CollectionOperationInfo::Content { sync_token },
+                topic: self
+                    .get_addressbook(&addressbook.principal, &addressbook.id, true)
+                    .await?
+                    .push_topic,
+            })
+        {
+            error!("Push notification about imported addressbook failed: {err}");
+        }
         Ok(())
     }
 }
@@ -664,7 +766,7 @@ async fn log_object_operation(
     addressbook_id: &str,
     object_id: &str,
     operation: ChangeOperation,
-) -> Result<String, sqlx::Error> {
+) -> Result<String, Error> {
     struct Synctoken {
         synctoken: i64,
     }
@@ -679,7 +781,8 @@ async fn log_object_operation(
         addressbook_id
     )
     .fetch_one(&mut **tx)
-    .await?;
+    .await
+    .map_err(crate::Error::from)?;
 
     sqlx::query!(
         r#"
@@ -693,6 +796,7 @@ async fn log_object_operation(
         operation
     )
     .execute(&mut **tx)
-    .await?;
+    .await
+    .map_err(crate::Error::from)?;
     Ok(format_synctoken(synctoken))
 }

crates/store_sqlite/src/calendar_store.rs

@@ -1,4 +1,5 @@
 use super::ChangeOperation;
+use crate::BEGIN_IMMEDIATE;
 use async_trait::async_trait;
 use chrono::TimeDelta;
 use derive_more::derive::Constructor;
@@ -10,25 +11,26 @@ use rustical_store::{CollectionOperation, CollectionOperationInfo};
 use sqlx::types::chrono::NaiveDateTime;
 use sqlx::{Acquire, Executor, Sqlite, SqlitePool, Transaction};
 use tokio::sync::mpsc::Sender;
-use tracing::{error, instrument};
+use tracing::{error, instrument, warn};
 
 #[derive(Debug, Clone)]
 struct CalendarObjectRow {
     id: String,
     ics: String,
+    uid: String,
 }
 
 impl TryFrom<CalendarObjectRow> for CalendarObject {
     type Error = rustical_store::Error;
 
     fn try_from(value: CalendarObjectRow) -> Result<Self, Self::Error> {
-        let object = Self::from_ics(value.ics)?;
+        let object = Self::from_ics(value.ics, Some(value.id))?;
-        if object.get_id() != value.id {
+        if object.get_uid() != value.uid {
             return Err(rustical_store::Error::IcalError(
                 rustical_ical::Error::InvalidData(format!(
-                    "object_id={} and UID={} don't match",
+                    "uid={} and UID={} don't match",
-                    object.get_id(),
+                    value.uid,
-                    value.id
+                    object.get_uid()
                 )),
             ));
         }
@@ -92,6 +94,53 @@ pub struct SqliteCalendarStore {
 }
 
 impl SqliteCalendarStore {
+    // Commit "orphaned" objects to the changelog table
+    pub async fn repair_orphans(&self) -> Result<(), Error> {
+        struct Row {
+            principal: String,
+            cal_id: String,
+            id: String,
+            deleted: bool,
+        }
+
+        let mut tx = self
+            .db
+            .begin_with(BEGIN_IMMEDIATE)
+            .await
+            .map_err(crate::Error::from)?;
+
+        let rows = sqlx::query_as!(
+            Row,
+            r#"
+                SELECT principal, cal_id, id, (deleted_at IS NOT NULL) AS "deleted: bool"
+                    FROM calendarobjects
+                    WHERE (principal, cal_id, id) NOT IN (
+                        SELECT DISTINCT principal, cal_id, object_id FROM calendarobjectchangelog
+                    )
+                ;
+                "#,
+        )
+        .fetch_all(&mut *tx)
+        .await
+        .map_err(crate::Error::from)?;
+
+        for row in rows {
+            let operation = if row.deleted {
+                ChangeOperation::Delete
+            } else {
+                ChangeOperation::Add
+            };
+            warn!(
+                "Commiting orphaned calendar object ({},{},{}), deleted={}",
+                &row.principal, &row.cal_id, &row.id, &row.deleted
+            );
+            log_object_operation(&mut tx, &row.principal, &row.cal_id, &row.id, operation).await?;
+        }
+        tx.commit().await.map_err(crate::Error::from)?;
+
+        Ok(())
+    }
+
     async fn _get_calendar<'e, E: Executor<'e, Database = Sqlite>>(
         executor: E,
         principal: &str,
@@ -280,7 +329,7 @@ impl SqliteCalendarStore {
     ) -> Result<Vec<CalendarObject>, Error> {
         sqlx::query_as!(
             CalendarObjectRow,
-            "SELECT id, ics FROM calendarobjects WHERE principal = ? AND cal_id = ? AND deleted_at IS NULL",
+            "SELECT id, uid, ics FROM calendarobjects WHERE principal = ? AND cal_id = ? AND deleted_at IS NULL",
             principal,
             cal_id
         )
@@ -305,7 +354,7 @@ impl SqliteCalendarStore {
 
         sqlx::query_as!(
             CalendarObjectRow,
-            r"SELECT id, ics FROM calendarobjects
+            r"SELECT id, uid, ics FROM calendarobjects
                 WHERE principal = ? AND cal_id = ? AND deleted_at IS NULL
                     AND (last_occurence IS NULL OR ? IS NULL OR last_occurence >= date(?))
                     AND (first_occurence IS NULL OR ? IS NULL OR first_occurence <= date(?))
@@ -334,7 +383,7 @@ impl SqliteCalendarStore {
     ) -> Result<CalendarObject, Error> {
         sqlx::query_as!(
             CalendarObjectRow,
-            "SELECT id, ics FROM calendarobjects WHERE (principal, cal_id, id) = (?, ?, ?) AND ((deleted_at IS NULL) OR ?)",
+            "SELECT id, uid, ics FROM calendarobjects WHERE (principal, cal_id, id) = (?, ?, ?) AND ((deleted_at IS NULL) OR ?)",
             principal,
             cal_id,
             object_id,
@@ -349,12 +398,12 @@ impl SqliteCalendarStore {
     #[instrument]
     async fn _put_object<'e, E: Executor<'e, Database = Sqlite>>(
         executor: E,
-        principal: String,
+        principal: &str,
-        cal_id: String,
+        cal_id: &str,
-        object: CalendarObject,
+        object: &CalendarObject,
         overwrite: bool,
     ) -> Result<(), Error> {
-        let (object_id, ics) = (object.get_id(), object.get_ics());
+        let (object_id, uid, ics) = (object.get_id(), object.get_uid(), object.get_ics());
 
         let first_occurence = object
             .get_first_occurence()
@@ -373,10 +422,11 @@ impl SqliteCalendarStore {
 
         (if overwrite {
             sqlx::query!(
-                "REPLACE INTO calendarobjects (principal, cal_id, id, ics, first_occurence, last_occurence, etag, object_type) VALUES (?, ?, ?, ?, date(?), date(?), ?, ?)",
+                "REPLACE INTO calendarobjects (principal, cal_id, id, uid, ics, first_occurence, last_occurence, etag, object_type) VALUES (?, ?, ?, ?, ?, date(?), date(?), ?, ?)",
                 principal,
                 cal_id,
                 object_id,
+                uid,
                 ics,
                 first_occurence,
                 last_occurence,
@@ -386,10 +436,11 @@ impl SqliteCalendarStore {
         } else {
             // If the object already exists a database error is thrown and handled in error.rs
             sqlx::query!(
-                "INSERT INTO calendarobjects (principal, cal_id, id, ics, first_occurence, last_occurence, etag, object_type) VALUES (?, ?, ?, ?, date(?), date(?), ?, ?)",
+                "INSERT INTO calendarobjects (principal, cal_id, id, uid, ics, first_occurence, last_occurence, etag, object_type) VALUES (?, ?, ?, ?, ?, date(?), date(?), ?, ?)",
                 principal,
                 cal_id,
                 object_id,
+                uid,
                 ics,
                 first_occurence,
                 last_occurence,
@@ -409,7 +460,7 @@ impl SqliteCalendarStore {
         executor: E,
         principal: &str,
         cal_id: &str,
-        id: &str,
+        object_id: &str,
         use_trashbin: bool,
     ) -> Result<(), Error> {
         if use_trashbin {
@@ -417,7 +468,7 @@ impl SqliteCalendarStore {
                 "UPDATE calendarobjects SET deleted_at = datetime(), updated_at = datetime() WHERE (principal, cal_id, id) = (?, ?, ?)",
                 principal,
                 cal_id,
-                id
+                object_id
             )
             .execute(executor)
             .await.map_err(crate::Error::from)?;
@@ -425,7 +476,7 @@ impl SqliteCalendarStore {
             sqlx::query!(
                 "DELETE FROM calendarobjects WHERE cal_id = ? AND id = ?",
                 cal_id,
-                id
+                object_id
             )
             .execute(executor)
             .await
@@ -539,7 +590,11 @@ impl CalendarStore for SqliteCalendarStore {
         id: &str,
         use_trashbin: bool,
     ) -> Result<(), Error> {
-        let mut tx = self.db.begin().await.map_err(crate::Error::from)?;
+        let mut tx = self
+            .db
+            .begin_with(BEGIN_IMMEDIATE)
+            .await
+            .map_err(crate::Error::from)?;
 
         let cal = match Self::_get_calendar(&mut *tx, principal, id, true).await {
             Ok(cal) => Some(cal),
@@ -573,7 +628,11 @@ impl CalendarStore for SqliteCalendarStore {
         objects: Vec<CalendarObject>,
         merge_existing: bool,
     ) -> Result<(), Error> {
-        let mut tx = self.db.begin().await.map_err(crate::Error::from)?;
+        let mut tx = self
+            .db
+            .begin_with(BEGIN_IMMEDIATE)
+            .await
+            .map_err(crate::Error::from)?;
 
         let existing_cal =
             match Self::_get_calendar(&mut *tx, &calendar.principal, &calendar.id, true).await {
@@ -588,18 +647,35 @@ impl CalendarStore for SqliteCalendarStore {
             Self::_insert_calendar(&mut *tx, calendar.clone()).await?;
         }
 
+        let mut sync_token = None;
         for object in objects {
-            Self::_put_object(
+            Self::_put_object(&mut *tx, &calendar.principal, &calendar.id, &object, false).await?;
-                &mut *tx,
+
-                calendar.principal.clone(),
+            sync_token = Some(
-                calendar.id.clone(),
+                log_object_operation(
-                object,
+                    &mut tx,
-                false,
+                    &calendar.principal,
+                    &calendar.id,
+                    object.get_id(),
+                    ChangeOperation::Add,
                 )
-            .await?;
+                .await?,
+            );
         }
 
         tx.commit().await.map_err(crate::Error::from)?;
+
+        if let Some(sync_token) = sync_token
+            && let Err(err) = self.sender.try_send(CollectionOperation {
+                data: CollectionOperationInfo::Content { sync_token },
+                topic: self
+                    .get_calendar(&calendar.principal, &calendar.id, true)
+                    .await?
+                    .push_topic,
+            })
+        {
+            error!("Push notification about imported calendar failed: {err}");
+        }
         Ok(())
     }
 
@@ -663,7 +739,11 @@ impl CalendarStore for SqliteCalendarStore {
         object: CalendarObject,
         overwrite: bool,
     ) -> Result<(), Error> {
-        let mut tx = self.db.begin().await.map_err(crate::Error::from)?;
+        let mut tx = self
+            .db
+            .begin_with(BEGIN_IMMEDIATE)
+            .await
+            .map_err(crate::Error::from)?;
 
         let object_id = object.get_id().to_owned();
 
@@ -673,14 +753,7 @@ impl CalendarStore for SqliteCalendarStore {
             return Err(Error::ReadOnly);
         }
 
-        Self::_put_object(
+        Self::_put_object(&mut *tx, &principal, &cal_id, &object, overwrite).await?;
-            &mut *tx,
-            principal.clone(),
-            cal_id.clone(),
-            object,
-            overwrite,
-        )
-        .await?;
 
         let sync_token = log_object_operation(
             &mut tx,
@@ -713,7 +786,11 @@ impl CalendarStore for SqliteCalendarStore {
         id: &str,
         use_trashbin: bool,
     ) -> Result<(), Error> {
-        let mut tx = self.db.begin().await.map_err(crate::Error::from)?;
+        let mut tx = self
+            .db
+            .begin_with(BEGIN_IMMEDIATE)
+            .await
+            .map_err(crate::Error::from)?;
 
         Self::_delete_object(&mut *tx, principal, cal_id, id, use_trashbin).await?;
 
@@ -737,7 +814,11 @@ impl CalendarStore for SqliteCalendarStore {
         cal_id: &str,
         object_id: &str,
     ) -> Result<(), Error> {
-        let mut tx = self.db.begin().await.map_err(crate::Error::from)?;
+        let mut tx = self
+            .db
+            .begin_with(BEGIN_IMMEDIATE)
+            .await
+            .map_err(crate::Error::from)?;
 
         Self::_restore_object(&mut *tx, principal, cal_id, object_id).await?;
 
@@ -750,7 +831,7 @@ impl CalendarStore for SqliteCalendarStore {
             data: CollectionOperationInfo::Content { sync_token },
             topic: self.get_calendar(principal, cal_id, true).await?.push_topic,
         }) {
-            error!("Push notification about deleted calendar failed: {err}");
+            error!("Push notification about restored calendar object failed: {err}");
         }
         Ok(())
     }
@@ -771,6 +852,7 @@ impl CalendarStore for SqliteCalendarStore {
 }
 
 // Logs an operation to the events
+// TODO: Log multiple updates
 async fn log_object_operation(
     tx: &mut Transaction<'_, Sqlite>,
     principal: &str,

crates/store_sqlite/src/lib.rs

@@ -10,6 +10,9 @@ pub mod error;
 pub mod principal_store;
 pub mod subscription_store;
 
+// Begin statement for write transactions
+pub const BEGIN_IMMEDIATE: &str = "BEGIN IMMEDIATE";
+
 #[cfg(any(test, feature = "test"))]
 pub mod tests;
 

crates/store_sqlite/src/tests/addressbook_store.rs

@@ -0,0 +1,81 @@
+#[cfg(test)]
+mod tests {
+    use crate::{addressbook_store::SqliteAddressbookStore, tests::get_test_addressbook_store};
+    use rstest::rstest;
+    use rustical_store::{Addressbook, AddressbookStore};
+
+    #[rstest]
+    #[tokio::test]
+    async fn test_addressbook_store(
+        #[from(get_test_addressbook_store)]
+        #[future]
+        addr_store: SqliteAddressbookStore,
+    ) {
+        let addr_store = addr_store.await;
+
+        let cal = Addressbook {
+            id: "addr".to_string(),
+            principal: "fake-user".to_string(),
+            displayname: None,
+            description: None,
+            deleted_at: None,
+            synctoken: 0,
+            push_topic: "alskdj".to_string(),
+        };
+
+        assert!(
+            addr_store.insert_addressbook(cal).await.is_err(),
+            "This should fail due to the user not existing "
+        );
+
+        let addr = Addressbook {
+            id: "addr".to_string(),
+            principal: "user".to_string(),
+            displayname: None,
+            description: None,
+            deleted_at: None,
+            synctoken: 0,
+            push_topic: "alskdj".to_string(),
+        };
+
+        addr_store.insert_addressbook(addr.clone()).await.unwrap();
+
+        assert_eq!(
+            addr_store
+                .get_addressbook("user", "addr", false)
+                .await
+                .unwrap(),
+            addr
+        );
+
+        addr_store
+            .delete_addressbook("user", "addr", true)
+            .await
+            .unwrap();
+
+        let Err(err) = addr_store.get_addressbook("user", "addr", false).await else {
+            panic!()
+        };
+        assert!(err.is_not_found());
+
+        addr_store
+            .get_addressbook("user", "addr", true)
+            .await
+            .unwrap();
+
+        addr_store
+            .restore_addressbook("user", "addr")
+            .await
+            .unwrap();
+
+        addr_store
+            .delete_addressbook("user", "addr", false)
+            .await
+            .unwrap();
+
+        let Err(err) = addr_store.get_addressbook("user", "addr", true).await else {
+            panic!()
+        };
+        assert!(err.is_not_found());
+    }
+}

crates/store_sqlite/src/tests/calendar_store.rs

@@ -0,0 +1,76 @@
+#[cfg(test)]
+mod tests {
+    use crate::{calendar_store::SqliteCalendarStore, tests::get_test_calendar_store};
+    use rstest::rstest;
+    use rustical_store::{Calendar, CalendarMetadata, CalendarStore};
+
+    #[rstest]
+    #[tokio::test]
+    async fn test_calendar_store(
+        #[from(get_test_calendar_store)]
+        #[future]
+        cal_store: SqliteCalendarStore,
+    ) {
+        let cal_store = cal_store.await;
+
+        let cal = Calendar {
+            principal: "fake-user".to_string(),
+            timezone_id: None,
+            deleted_at: None,
+            meta: CalendarMetadata::default(),
+            id: "cal".to_string(),
+            synctoken: 0,
+            subscription_url: None,
+            push_topic: "alskdj".to_string(),
+            components: vec![],
+        };
+
+        assert!(
+            cal_store.insert_calendar(cal).await.is_err(),
+            "This should fail due to the user not existing "
+        );
+
+        let cal = Calendar {
+            principal: "user".to_string(),
+            timezone_id: None,
+            deleted_at: None,
+            meta: CalendarMetadata::default(),
+            id: "cal".to_string(),
+            synctoken: 0,
+            subscription_url: None,
+            push_topic: "alskdj".to_string(),
+            components: vec![],
+        };
+
+        cal_store.insert_calendar(cal.clone()).await.unwrap();
+
+        assert_eq!(
+            cal_store.get_calendar("user", "cal", false).await.unwrap(),
+            cal
+        );
+
+        cal_store
+            .delete_calendar("user", "cal", true)
+            .await
+            .unwrap();
+
+        let Err(err) = cal_store.get_calendar("user", "cal", false).await else {
+            panic!()
+        };
+        assert!(err.is_not_found());
+
+        cal_store.get_calendar("user", "cal", true).await.unwrap();
+
+        cal_store.restore_calendar("user", "cal").await.unwrap();
+
+        cal_store
+            .delete_calendar("user", "cal", false)
+            .await
+            .unwrap();
+
+        let Err(err) = cal_store.get_calendar("user", "cal", true).await else {
+            panic!()
+        };
+        assert!(err.is_not_found());
+    }
+}

crates/store_sqlite/src/tests/mod.rs

@@ -8,6 +8,9 @@ use tokio::sync::OnceCell;
 
 static DB: OnceCell<SqlitePool> = OnceCell::const_new();
 
+mod addressbook_store;
+mod calendar_store;
+
 async fn get_test_db() -> SqlitePool {
     DB.get_or_init(async || {
         let db = SqlitePool::connect("sqlite::memory:").await.unwrap();

crates/xml/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "rustical_xml"
 version.workspace = true
+rust-version.workspace = true
 edition.workspace = true
 description.workspace = true
 repository.workspace = true