@luckydye/calendar 1.3.1 → 1.4.0

package/src/IndexedDBStorage.ts

@@ -1,32 +1,38 @@
-import type { CalendarEvent, Organizer, Attendee, NotificationConfig } from "./CalendarInternal.js";
+import type {
+	Attendee,
+	CalendarEvent,
+	NotificationConfig,
+	Organizer,
+} from "./CalendarInternal.js";
 import type { CalendarStorage, SyncMetadata } from "./CalendarStorage.js";
 
 interface SerializedEvent {
-  id: string;
-  title: string;
-  start: string; // ISO date string
-  end: string; // ISO date string
-  color?: string;
-  calendar?: string;
-  calendarId?: string;
-  sourceId?: string;
-  description?: string;
-  location?: string;
-  url?: string;
-  rrule?: string;
-  readOnly?: boolean;
-  lastSynced?: string; // ISO date string
-  organizer?: Organizer;
-  attendees?: Attendee[];
-  status?: 'TENTATIVE' | 'CONFIRMED' | 'CANCELLED';
-  isAllDay?: boolean;
-  reminders?: NotificationConfig[];
-  visualStyle?: 'heatmap';
+	id: string;
+	title: string;
+	start: string; // ISO date string
+	end: string; // ISO date string
+	color?: string;
+	calendar?: string;
+	calendarId?: string;
+	sourceId?: string;
+	description?: string;
+	location?: string;
+	url?: string;
+	rrule?: string;
+	readOnly?: boolean;
+	lastSynced?: string; // ISO date string
+	organizer?: Organizer;
+	attendees?: Attendee[];
+	status?: "TENTATIVE" | "CONFIRMED" | "CANCELLED";
+	isAllDay?: boolean;
+	reminders?: NotificationConfig[];
+	visualStyle?: "heatmap";
+	resourceUrl?: string;
 }
 
 interface SerializedMetadata {
-  sourceId: string;
-  lastSync: string; // ISO date string
+	sourceId: string;
+	lastSync: string; // ISO date string
 }
 
 /**
@@ -34,376 +40,419 @@ interface SerializedMetadata {
  * Uses differential sync to efficiently update events.
  */
 export class IndexedDBStorage implements CalendarStorage {
-  dbName = "calendar-events";
-  storeName = "events";
-  metadataStoreName = "metadata";
-  version = 8;
-
-  db?: IDBDatabase;
-  openPromise?: Promise<IDBDatabase>;
-
-  async recreateDatabase(): Promise<void> {
-    if (this.db) {
-      this.db.close();
-      this.db = undefined;
-    }
-    this.openPromise = undefined;
-
-    return new Promise((resolve, reject) => {
-      const deleteRequest = indexedDB.deleteDatabase(this.dbName);
-
-      deleteRequest.onerror = () => {
-        reject(new Error(`Failed to delete database: ${deleteRequest.error?.message}`));
-      };
-
-      deleteRequest.onsuccess = () => {
-        resolve();
-      };
-    });
-  }
-
-  async open(): Promise<IDBDatabase> {
-    if (this.db) {
-      return this.db;
-    }
-
-    if (this.openPromise) {
-      return this.openPromise;
-    }
-
-    this.openPromise = new Promise((resolve, reject) => {
-      const request = indexedDB.open(this.dbName, this.version);
-
-      request.onerror = () => {
-        this.openPromise = undefined;
-        reject(new Error(`Failed to open IndexedDB: ${request.error?.message}`));
-      };
-
-      request.onsuccess = () => {
-        this.db = request.result;
-        this.openPromise = undefined;
-        resolve(request.result);
-      };
-
-      request.onupgradeneeded = (event) => {
-        const db = (event.target as IDBOpenDBRequest).result;
-        const transaction = (event.target as IDBOpenDBRequest).transaction;
-
-        if (!transaction) {
-          throw new Error("Transaction not available during upgrade");
-        }
-
-        let store: IDBObjectStore;
-
-        if (!db.objectStoreNames.contains(this.storeName)) {
-          store = db.createObjectStore(this.storeName, { keyPath: "id" });
-          store.createIndex("start", "start", { unique: false });
-          store.createIndex("end", "end", { unique: false });
-          store.createIndex("calendar", "calendar", { unique: false });
-          store.createIndex("calendarSync", ["calendar", "lastSynced"], { unique: false });
-        } else {
-          store = transaction.objectStore(this.storeName);
-          if (!store.indexNames.contains("calendar")) {
-            store.createIndex("calendar", "calendar", { unique: false });
-          }
-          if (!store.indexNames.contains("calendarSync")) {
-            store.createIndex("calendarSync", ["calendar", "lastSynced"], { unique: false });
-          }
-        }
-
-        if (!db.objectStoreNames.contains(this.metadataStoreName)) {
-          db.createObjectStore(this.metadataStoreName, { keyPath: "sourceId" });
-        }
-      };
-    });
-
-    return this.openPromise;
-  }
-
-  async loadEvents(): Promise<CalendarEvent[]> {
-    const db = await this.open();
-
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.storeName, "readonly");
-      const store = transaction.objectStore(this.storeName);
-      const request = store.getAll();
-
-      request.onerror = () => {
-        reject(new Error(`Failed to load events: ${request.error?.message}`));
-      };
-
-      request.onsuccess = () => {
-        const serializedEvents = request.result as SerializedEvent[];
-        const events = serializedEvents.map(e => this.deserializeEvent(e));
-        resolve(events);
-      };
-    });
-  }
-
-  async queryEvents(start: Date, end: Date): Promise<CalendarEvent[]> {
-    const db = await this.open();
-
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.storeName, "readonly");
-      const store = transaction.objectStore(this.storeName);
-      const index = store.index("start");
-
-      const startTime = start.toISOString();
-      const endTime = end.toISOString();
-
-      // Get all events that start at or before the query end time
-      const range = IDBKeyRange.upperBound(endTime);
-      const request = index.getAll(range);
-
-      request.onerror = () => {
-        reject(new Error(`Failed to query events: ${request.error?.message}`));
-      };
-
-      request.onsuccess = () => {
-        const serializedEvents = request.result as SerializedEvent[];
-
-        // Filter to only events that end at or after the query start time
-        const overlappingEvents = serializedEvents.filter(e => e.end >= startTime);
-
-        const events = overlappingEvents.map(e => this.deserializeEvent(e));
-        resolve(events);
-      };
-    });
-  }
-
-  async sync(events: CalendarEvent[], syncedSources: Map<string, Date>): Promise<void> {
-    const db = await this.open();
-
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.storeName, "readwrite");
-      const store = transaction.objectStore(this.storeName);
-      const calendarIndex = store.index("calendar");
-
-      // Upsert all new/updated events
-      for (const event of events) {
-        const serialized = this.serializeEvent(event);
-        store.put(serialized);
-      }
-
-      // For each synced source (including those with 0 events), delete stale events using cursor
-      for (const [calendar, syncTimestamp] of syncedSources.entries()) {
-        const latestSyncStr = syncTimestamp.toISOString();
-        const range = IDBKeyRange.only(calendar);
-        const cursorRequest = calendarIndex.openCursor(range);
-
-        cursorRequest.onsuccess = () => {
-          const cursor = cursorRequest.result;
-          if (cursor) {
-            const storedEvent = cursor.value as SerializedEvent;
-            // Delete if no lastSynced or if lastSynced is older than latest sync
-            if (!storedEvent.lastSynced || storedEvent.lastSynced < latestSyncStr) {
-              console.debug("sync deleted", storedEvent.id);
-              store.delete(storedEvent.id);
-            }
-            cursor.continue();
-          }
-        };
-
-        cursorRequest.onerror = () => {
-          reject(new Error(`Failed to query calendar events: ${cursorRequest.error?.message}`));
-        };
-      }
-
-      transaction.oncomplete = () => {
-        resolve();
-      };
-
-      transaction.onerror = () => {
-        reject(new Error(`Failed to save events: ${transaction.error?.message}`));
-      };
-    });
-  }
-
-  async clear(): Promise<void> {
-    const db = await this.open();
-
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.storeName, "readwrite");
-      const store = transaction.objectStore(this.storeName);
-      const request = store.clear();
-
-      request.onerror = () => {
-        reject(new Error(`Failed to clear storage: ${request.error?.message}`));
-      };
-
-      request.onsuccess = () => {
-        resolve();
-      };
-    });
-  }
-
-  async getSyncMetadata(sourceId: string): Promise<SyncMetadata | undefined> {
-    const db = await this.open();
-
-    if (!db.objectStoreNames.contains(this.metadataStoreName)) {
-      await this.recreateDatabase();
-      return this.getSyncMetadata(sourceId);
-    }
-
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.metadataStoreName, "readonly");
-      const store = transaction.objectStore(this.metadataStoreName);
-      const request = store.get(sourceId);
-
-      request.onerror = () => {
-        reject(new Error(`Failed to get sync metadata: ${request.error?.message}`));
-      };
-
-      request.onsuccess = () => {
-        const serialized = request.result as SerializedMetadata | undefined;
-        if (!serialized) {
-          resolve(undefined);
-          return;
-        }
-
-        resolve({
-          lastSync: new Date(serialized.lastSync),
-        });
-      };
-    });
-  }
-
-  async setSyncMetadata(sourceId: string, metadata: SyncMetadata): Promise<void> {
-    const db = await this.open();
-
-    if (!db.objectStoreNames.contains(this.metadataStoreName)) {
-      await this.recreateDatabase();
-      return this.setSyncMetadata(sourceId, metadata);
-    }
-
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.metadataStoreName, "readwrite");
-      const store = transaction.objectStore(this.metadataStoreName);
-
-      const serialized: SerializedMetadata = {
-        sourceId,
-        lastSync: metadata.lastSync.toISOString(),
-      };
-
-      const request = store.put(serialized);
-
-      request.onerror = () => {
-        reject(new Error(`Failed to set sync metadata: ${request.error?.message}`));
-      };
-
-      request.onsuccess = () => {
-        resolve();
-      };
-    });
-  }
-
-  serializeEvent(event: CalendarEvent): SerializedEvent {
-    // For all-day events, store as local date string (YYYY-MM-DD) to preserve the date
-    // For timed events, store as ISO string
-    const start = event.isAllDay
-      ? `${event.start.getFullYear()}-${String(event.start.getMonth() + 1).padStart(2, '0')}-${String(event.start.getDate()).padStart(2, '0')}`
-      : event.start.toISOString();
-    const end = event.isAllDay
-      ? `${event.end.getFullYear()}-${String(event.end.getMonth() + 1).padStart(2, '0')}-${String(event.end.getDate()).padStart(2, '0')}`
-      : event.end.toISOString();
-
-    return {
-      id: event.id,
-      title: event.title,
-      start,
-      end,
-      color: event.color,
-      calendar: event.calendar,
-      calendarId: event.calendarId,
-      sourceId: event.sourceId,
-      description: event.description,
-      location: event.location,
-      url: event.url,
-      rrule: event.rrule,
-      readOnly: event.readOnly,
-      lastSynced: event.lastSynced?.toISOString(),
-      organizer: event.organizer,
-      attendees: event.attendees,
-      status: event.status,
-      isAllDay: event.isAllDay,
-      reminders: event.reminders,
-      visualStyle: event.visualStyle,
-    };
-  }
-
-  deserializeEvent(serialized: SerializedEvent): CalendarEvent {
-    // Parse dates - for all-day events, parse as local date to avoid UTC shifts
-    let start: Date;
-    let end: Date;
-
-    if (serialized.isAllDay) {
-      // Parse as local date (YYYY-MM-DD format)
-      const startParts = serialized.start.split('-').map(Number);
-      if (startParts.length === 3 && startParts.every(p => !Number.isNaN(p))) {
-        const [year, month, day] = startParts as [number, number, number];
-        start = new Date(year, month - 1, day);
-      } else {
-        start = new Date(serialized.start);
-      }
-      const endParts = serialized.end.split('-').map(Number);
-      if (endParts.length === 3 && endParts.every(p => !Number.isNaN(p))) {
-        const [year, month, day] = endParts as [number, number, number];
-        end = new Date(year, month - 1, day);
-      } else {
-        end = new Date(serialized.end);
-      }
-    } else {
-      start = new Date(serialized.start);
-      end = new Date(serialized.end);
-    }
-
-    return {
-      id: serialized.id,
-      title: serialized.title,
-      start,
-      end,
-      color: serialized.color,
-      calendar: serialized.calendar,
-      calendarId: serialized.calendarId,
-      sourceId: serialized.sourceId,
-      description: serialized.description,
-      location: serialized.location,
-      url: serialized.url,
-      rrule: serialized.rrule,
-      readOnly: serialized.readOnly,
-      lastSynced: serialized.lastSynced ? new Date(serialized.lastSynced) : undefined,
-      organizer: serialized.organizer,
-      attendees: serialized.attendees,
-      status: serialized.status,
-      isAllDay: serialized.isAllDay,
-      reminders: serialized.reminders,
-      visualStyle: serialized.visualStyle,
-    };
-  }
-
-  async putEvent(event: CalendarEvent): Promise<void> {
-    const db = await this.open();
-
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.storeName, "readwrite");
-      const store = transaction.objectStore(this.storeName);
-      store.put(this.serializeEvent(event));
-
-      transaction.oncomplete = () => resolve();
-      transaction.onerror = () => reject(transaction.error);
-    });
-  }
-
-  async deleteEvent(id: string): Promise<void> {
-    const db = await this.open();
-
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(this.storeName, "readwrite");
-      const store = transaction.objectStore(this.storeName);
-      store.delete(id);
-
-      transaction.oncomplete = () => resolve();
-      transaction.onerror = () => reject(transaction.error);
-    });
-  }
+	dbName = "calendar-events";
+	storeName = "events";
+	metadataStoreName = "metadata";
+	version = 8;
+
+	db?: IDBDatabase;
+	openPromise?: Promise<IDBDatabase>;
+
+	async recreateDatabase(): Promise<void> {
+		if (this.db) {
+			this.db.close();
+			this.db = undefined;
+		}
+		this.openPromise = undefined;
+
+		return new Promise((resolve, reject) => {
+			const deleteRequest = indexedDB.deleteDatabase(this.dbName);
+
+			deleteRequest.onerror = () => {
+				reject(
+					new Error(
+						`Failed to delete database: ${deleteRequest.error?.message}`,
+					),
+				);
+			};
+
+			deleteRequest.onsuccess = () => {
+				resolve();
+			};
+		});
+	}
+
+	async open(): Promise<IDBDatabase> {
+		if (this.db) {
+			return this.db;
+		}
+
+		if (this.openPromise) {
+			return this.openPromise;
+		}
+
+		this.openPromise = new Promise((resolve, reject) => {
+			const request = indexedDB.open(this.dbName, this.version);
+
+			request.onerror = () => {
+				this.openPromise = undefined;
+				reject(
+					new Error(`Failed to open IndexedDB: ${request.error?.message}`),
+				);
+			};
+
+			request.onsuccess = () => {
+				this.db = request.result;
+				this.openPromise = undefined;
+				resolve(request.result);
+			};
+
+			request.onupgradeneeded = (event) => {
+				const db = (event.target as IDBOpenDBRequest).result;
+				const transaction = (event.target as IDBOpenDBRequest).transaction;
+
+				if (!transaction) {
+					throw new Error("Transaction not available during upgrade");
+				}
+
+				let store: IDBObjectStore;
+
+				if (!db.objectStoreNames.contains(this.storeName)) {
+					store = db.createObjectStore(this.storeName, { keyPath: "id" });
+					store.createIndex("start", "start", { unique: false });
+					store.createIndex("end", "end", { unique: false });
+					store.createIndex("calendar", "calendar", { unique: false });
+					store.createIndex("calendarSync", ["calendar", "lastSynced"], {
+						unique: false,
+					});
+				} else {
+					store = transaction.objectStore(this.storeName);
+					if (!store.indexNames.contains("calendar")) {
+						store.createIndex("calendar", "calendar", { unique: false });
+					}
+					if (!store.indexNames.contains("calendarSync")) {
+						store.createIndex("calendarSync", ["calendar", "lastSynced"], {
+							unique: false,
+						});
+					}
+				}
+
+				if (!db.objectStoreNames.contains(this.metadataStoreName)) {
+					db.createObjectStore(this.metadataStoreName, { keyPath: "sourceId" });
+				}
+			};
+		});
+
+		return this.openPromise;
+	}
+
+	async loadEvents(): Promise<CalendarEvent[]> {
+		const db = await this.open();
+
+		return new Promise((resolve, reject) => {
+			const transaction = db.transaction(this.storeName, "readonly");
+			const store = transaction.objectStore(this.storeName);
+			const request = store.getAll();
+
+			request.onerror = () => {
+				reject(new Error(`Failed to load events: ${request.error?.message}`));
+			};
+
+			request.onsuccess = () => {
+				const serializedEvents = request.result as SerializedEvent[];
+				const events = serializedEvents.map((e) => this.deserializeEvent(e));
+				resolve(events);
+			};
+		});
+	}
+
+	async queryEvents(start: Date, end: Date): Promise<CalendarEvent[]> {
+		const db = await this.open();
+
+		return new Promise((resolve, reject) => {
+			const transaction = db.transaction(this.storeName, "readonly");
+			const store = transaction.objectStore(this.storeName);
+			const index = store.index("start");
+
+			const startTime = start.toISOString();
+			const endTime = end.toISOString();
+
+			// Get all events that start at or before the query end time
+			const range = IDBKeyRange.upperBound(endTime);
+			const request = index.getAll(range);
+
+			request.onerror = () => {
+				reject(new Error(`Failed to query events: ${request.error?.message}`));
+			};
+
+			request.onsuccess = () => {
+				const serializedEvents = request.result as SerializedEvent[];
+
+				// Filter to only events that end at or after the query start time
+				const overlappingEvents = serializedEvents.filter(
+					(e) => e.end >= startTime,
+				);
+
+				const events = overlappingEvents.map((e) => this.deserializeEvent(e));
+				resolve(events);
+			};
+		});
+	}
+
+	async sync(
+		events: CalendarEvent[],
+		syncedSources: Map<string, Date>,
+	): Promise<void> {
+		const db = await this.open();
+
+		return new Promise((resolve, reject) => {
+			const transaction = db.transaction(this.storeName, "readwrite");
+			const store = transaction.objectStore(this.storeName);
+			const calendarIndex = store.index("calendar");
+
+			// Upsert all new/updated events
+			for (const event of events) {
+				const serialized = this.serializeEvent(event);
+				store.put(serialized);
+			}
+
+			// For each synced source (including those with 0 events), delete stale events using cursor
+			for (const [calendar, syncTimestamp] of syncedSources.entries()) {
+				const latestSyncStr = syncTimestamp.toISOString();
+				const range = IDBKeyRange.only(calendar);
+				const cursorRequest = calendarIndex.openCursor(range);
+
+				cursorRequest.onsuccess = () => {
+					const cursor = cursorRequest.result;
+					if (cursor) {
+						const storedEvent = cursor.value as SerializedEvent;
+						// Delete if no lastSynced or if lastSynced is older than latest sync
+						if (
+							!storedEvent.lastSynced ||
+							storedEvent.lastSynced < latestSyncStr
+						) {
+							console.debug("sync deleted", storedEvent.id);
+							store.delete(storedEvent.id);
+						}
+						cursor.continue();
+					}
+				};
+
+				cursorRequest.onerror = () => {
+					reject(
+						new Error(
+							`Failed to query calendar events: ${cursorRequest.error?.message}`,
+						),
+					);
+				};
+			}
+
+			transaction.oncomplete = () => {
+				resolve();
+			};
+
+			transaction.onerror = () => {
+				reject(
+					new Error(`Failed to save events: ${transaction.error?.message}`),
+				);
+			};
+		});
+	}
+
+	async clear(): Promise<void> {
+		const db = await this.open();
+
+		return new Promise((resolve, reject) => {
+			const transaction = db.transaction(this.storeName, "readwrite");
+			const store = transaction.objectStore(this.storeName);
+			const request = store.clear();
+
+			request.onerror = () => {
+				reject(new Error(`Failed to clear storage: ${request.error?.message}`));
+			};
+
+			request.onsuccess = () => {
+				resolve();
+			};
+		});
+	}
+
+	async getSyncMetadata(sourceId: string): Promise<SyncMetadata | undefined> {
+		const db = await this.open();
+
+		if (!db.objectStoreNames.contains(this.metadataStoreName)) {
+			await this.recreateDatabase();
+			return this.getSyncMetadata(sourceId);
+		}
+
+		return new Promise((resolve, reject) => {
+			const transaction = db.transaction(this.metadataStoreName, "readonly");
+			const store = transaction.objectStore(this.metadataStoreName);
+			const request = store.get(sourceId);
+
+			request.onerror = () => {
+				reject(
+					new Error(`Failed to get sync metadata: ${request.error?.message}`),
+				);
+			};
+
+			request.onsuccess = () => {
+				const serialized = request.result as SerializedMetadata | undefined;
+				if (!serialized) {
+					resolve(undefined);
+					return;
+				}
+
+				resolve({
+					lastSync: new Date(serialized.lastSync),
+				});
+			};
+		});
+	}
+
+	async setSyncMetadata(
+		sourceId: string,
+		metadata: SyncMetadata,
+	): Promise<void> {
+		const db = await this.open();
+
+		if (!db.objectStoreNames.contains(this.metadataStoreName)) {
+			await this.recreateDatabase();
+			return this.setSyncMetadata(sourceId, metadata);
+		}
+
+		return new Promise((resolve, reject) => {
+			const transaction = db.transaction(this.metadataStoreName, "readwrite");
+			const store = transaction.objectStore(this.metadataStoreName);
+
+			const serialized: SerializedMetadata = {
+				sourceId,
+				lastSync: metadata.lastSync.toISOString(),
+			};
+
+			const request = store.put(serialized);
+
+			request.onerror = () => {
+				reject(
+					new Error(`Failed to set sync metadata: ${request.error?.message}`),
+				);
+			};
+
+			request.onsuccess = () => {
+				resolve();
+			};
+		});
+	}
+
+	serializeEvent(event: CalendarEvent): SerializedEvent {
+		// For all-day events, store as local date string (YYYY-MM-DD) to preserve the date
+		// For timed events, store as ISO string
+		const start = event.isAllDay
+			? `${event.start.getFullYear()}-${String(
+					event.start.getMonth() + 1,
+			  ).padStart(2, "0")}-${String(event.start.getDate()).padStart(2, "0")}`
+			: event.start.toISOString();
+		const end = event.isAllDay
+			? `${event.end.getFullYear()}-${String(event.end.getMonth() + 1).padStart(
+					2,
+					"0",
+			  )}-${String(event.end.getDate()).padStart(2, "0")}`
+			: event.end.toISOString();
+
+		return {
+			id: event.id,
+			title: event.title,
+			start,
+			end,
+			color: event.color,
+			calendar: event.calendar,
+			calendarId: event.calendarId,
+			sourceId: event.sourceId,
+			description: event.description,
+			location: event.location,
+			url: event.url,
+			rrule: event.rrule,
+			readOnly: event.readOnly,
+			lastSynced: event.lastSynced?.toISOString(),
+			organizer: event.organizer,
+			attendees: event.attendees,
+			status: event.status,
+			isAllDay: event.isAllDay,
+			reminders: event.reminders,
+			visualStyle: event.visualStyle,
+			resourceUrl: event.resourceUrl,
+		};
+	}
+
+	deserializeEvent(serialized: SerializedEvent): CalendarEvent {
+		// Parse dates - for all-day events, parse as local date to avoid UTC shifts
+		let start: Date;
+		let end: Date;
+
+		if (serialized.isAllDay) {
+			// Parse as local date (YYYY-MM-DD format)
+			const startParts = serialized.start.split("-").map(Number);
+			if (
+				startParts.length === 3 &&
+				startParts.every((p) => !Number.isNaN(p))
+			) {
+				const [year, month, day] = startParts as [number, number, number];
+				start = new Date(year, month - 1, day);
+			} else {
+				start = new Date(serialized.start);
+			}
+			const endParts = serialized.end.split("-").map(Number);
+			if (endParts.length === 3 && endParts.every((p) => !Number.isNaN(p))) {
+				const [year, month, day] = endParts as [number, number, number];
+				end = new Date(year, month - 1, day);
+			} else {
+				end = new Date(serialized.end);
+			}
+		} else {
+			start = new Date(serialized.start);
+			end = new Date(serialized.end);
+		}
+
+		return {
+			id: serialized.id,
+			title: serialized.title,
+			start,
+			end,
+			color: serialized.color,
+			calendar: serialized.calendar,
+			calendarId: serialized.calendarId,
+			sourceId: serialized.sourceId,
+			description: serialized.description,
+			location: serialized.location,
+			url: serialized.url,
+			rrule: serialized.rrule,
+			readOnly: serialized.readOnly,
+			lastSynced: serialized.lastSynced
+				? new Date(serialized.lastSynced)
+				: undefined,
+			organizer: serialized.organizer,
+			attendees: serialized.attendees,
+			status: serialized.status,
+			isAllDay: serialized.isAllDay,
+			reminders: serialized.reminders,
+			visualStyle: serialized.visualStyle,
+			resourceUrl: serialized.resourceUrl,
+		};
+	}
+
+	async putEvent(event: CalendarEvent): Promise<void> {
+		const db = await this.open();
+
+		return new Promise((resolve, reject) => {
+			const transaction = db.transaction(this.storeName, "readwrite");
+			const store = transaction.objectStore(this.storeName);
+			store.put(this.serializeEvent(event));
+
+			transaction.oncomplete = () => resolve();
+			transaction.onerror = () => reject(transaction.error);
+		});
+	}
+
+	async deleteEvent(id: string): Promise<void> {
+		const db = await this.open();
+
+		return new Promise((resolve, reject) => {
+			const transaction = db.transaction(this.storeName, "readwrite");
+			const store = transaction.objectStore(this.storeName);
+			store.delete(id);
+
+			transaction.oncomplete = () => resolve();
+			transaction.onerror = () => reject(transaction.error);
+		});
+	}
 }