@luckydye/calendar 1.1.0 → 1.1.2

package/src/IndexedDBStorage.ts

@@ -0,0 +1,393 @@
+import type { CalendarEvent, Organizer, Attendee, NotificationConfig } 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[];
+}
+
+interface SerializedMetadata {
+  sourceId: string;
+  lastSync: string; // ISO date string
+}
+
+/**
+ * IndexedDB storage implementation for calendar events.
+ * 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,
+    };
+  }
+
+  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,
+    };
+  }
+
+  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);
+    });
+  }
+}

package/src/InhouseBookingSource.ts

@@ -0,0 +1,237 @@
+import type { CalendarEvent } from "./CalendarInternal.js";
+import type { CalendarSource, CalendarCredentials } from "./CalendarIntegration.js";
+
+/**
+ * Inhouse Booking System credentials.
+ */
+export interface InhouseCredentials extends CalendarCredentials {
+  /**
+   * Session cookie for authentication (e.g., "sessionid=abc123; csrftoken=xyz789")
+   */
+  sessionCookie: string;
+  /**
+   * Employee ID to filter bookings for
+   */
+  employeeId: string;
+  /**
+   * Unit ID (optional, for filtering by unit/location)
+   */
+  unitId?: string;
+}
+
+/**
+ * Inhouse Booking System API response structure.
+ */
+interface InhouseBooking {
+  id: string | number;
+  date: string;
+  timeslots: number;
+  description: string;
+  employee_id: number;
+  closing_id?: number;
+  project_id?: number;
+  owner_id?: number;
+  updated_user_id?: number;
+  home_office?: number;
+  out_of_office?: number;
+  optional?: number;
+  deadline?: number;
+  created_at?: string;
+  updated_at?: string;
+  deleted_at?: string | null;
+}
+
+/**
+ * Inhouse Booking System source for syncing with internal booking API.
+ *
+ * @example
+ * const source = new InhouseBookingSource(
+ *   'inhouse-1',
+ *   'My Bookings',
+ *   '#4285F4',
+ *   {
+ *     sessionCookie: 'sessionid=abc123',
+ *     employeeId: '589',
+ *     unitId: '3'
+ *   }
+ * );
+ *
+ * const events = await source.fetchEvents();
+ */
+export class InhouseBookingSource implements CalendarSource {
+  readonly type = 'inhouse';
+  credentials: InhouseCredentials;
+  enabled: boolean;
+
+  constructor(
+    public id: string,
+    public name: string,
+    public color: string,
+    credentials: InhouseCredentials,
+    enabled = true
+  ) {
+    this.credentials = credentials;
+    this.enabled = enabled;
+  }
+
+  /**
+   * Make an authenticated request to the Inhouse Booking API via the proxy.
+   * The proxy will inject the session cookie.
+   */
+  private async apiRequest<T>(endpoint: string): Promise<T> {
+    const url = `/bookings${endpoint}`;
+    
+    const response = await fetch(url, {
+      headers: {
+        'X-Session-Cookie': this.credentials.sessionCookie,
+      },
+    });
+
+    if (!response.ok) {
+      if (response.status === 401) {
+        throw new Error('Inhouse Booking System authentication failed. Please check your session cookie.');
+      }
+      throw new Error(`Inhouse Booking API error: ${response.status} ${response.statusText}`);
+    }
+
+    return response.json() as Promise<T>;
+  }
+
+  /**
+   * Convert an Inhouse booking to internal CalendarEvent format.
+   * Bookings use date + timeslots (each quarter = 2 hours in an 8-hour work day).
+   * Bookings are ordered by their position in the day (first booking = starts at 09:00).
+   */
+  private mapBookingToEvent(
+    booking: InhouseBooking,
+    startTime: Date
+  ): CalendarEvent | null {
+    if (!booking.date || !booking.timeslots) return null;
+
+    // Each quarter = 2 hours (8-hour day / 4 quarters)
+    const quarterHours = 2;
+    const durationHours = booking.timeslots * quarterHours;
+    const endTime = new Date(startTime.getTime() + durationHours * 60 * 60 * 1000);
+
+    if (Number.isNaN(startTime.getTime()) || Number.isNaN(endTime.getTime())) return null;
+
+    const title = booking.description || 'Booking';
+
+    return {
+      id: String(booking.id),
+      title: title,
+      start: startTime,
+      end: endTime,
+      color: this.color,
+      calendar: this.name,
+      calendarId: this.id,
+      sourceId: this.id,
+      description: `${booking.timeslots} quarter${booking.timeslots > 1 ? 's' : ''} (${durationHours}h)`,
+      readOnly: true,
+      status: booking.optional === 1 ? 'TENTATIVE' : undefined,
+    };
+  }
+
+  /**
+   * Process bookings and calculate their timestamps based on order.
+   * Bookings are stacked chronologically - first booking starts at 09:00.
+   */
+  private processBookings(bookings: InhouseBooking[]): CalendarEvent[] {
+    // Group bookings by date
+    const bookingsByDate = new Map<string, InhouseBooking[]>();
+    
+    for (const booking of bookings) {
+      if (!booking.date) continue;
+      const list = bookingsByDate.get(booking.date) || [];
+      list.push(booking);
+      bookingsByDate.set(booking.date, list);
+    }
+
+    const events: CalendarEvent[] = [];
+
+    for (const [dateStr, dateBookings] of bookingsByDate) {
+      // Parse date (format: "2025-03-07")
+      const [year, month, day] = dateStr.split('-').map(Number);
+      if (!year || !month || !day) continue;
+
+      // Start of work day: 09:00
+      let currentTime = new Date(year, month - 1, day, 9, 0);
+
+      // Process bookings in order (API returns them in chronological order)
+      for (const booking of dateBookings) {
+        const event = this.mapBookingToEvent(booking, currentTime);
+        if (event) {
+          events.push(event);
+          // Advance current time for next booking
+          currentTime = event.end;
+        }
+      }
+    }
+
+    return events;
+  }
+
+  /**
+   * Fetch bookings from the Inhouse Booking System.
+   * Fetches bookings from 1 year ago to 1 year in the future.
+   */
+  async fetchEvents(): Promise<CalendarEvent[]> {
+    if (!this.enabled) return [];
+
+    const now = new Date();
+    const oneYearAgo = new Date(now.getTime() - 365 * 24 * 60 * 60 * 1000);
+    const oneYearFuture = new Date(now.getTime() + 365 * 24 * 60 * 60 * 1000);
+
+    const formatDate = (date: Date): string => date.toISOString().split('T')[0];
+
+    const dateFilter = {
+      '>=': formatDate(oneYearAgo),
+      '<=': formatDate(oneYearFuture),
+    };
+
+    const employeeFilter = {
+      '=': this.credentials.employeeId,
+    };
+
+    const params = new URLSearchParams({
+      date: JSON.stringify(dateFilter),
+      employee_id: JSON.stringify(employeeFilter),
+    });
+
+    if (this.credentials.unitId) {
+      params.set('unit_id', this.credentials.unitId);
+    }
+
+    const bookings = await this.apiRequest<InhouseBooking[]>(`?${params}`);
+
+    if (!Array.isArray(bookings)) return [];
+
+    return this.processBookings(bookings);
+  }
+
+  /**
+   * Test the connection to the Inhouse Booking System.
+   * Returns true if the credentials are valid.
+   */
+  async testConnection(): Promise<boolean> {
+    try {
+      const now = new Date();
+      const dateFilter = {
+        '>=': now.toISOString().split('T')[0],
+        '<=': now.toISOString().split('T')[0],
+      };
+      const employeeFilter = { '=': this.credentials.employeeId };
+      
+      const params = new URLSearchParams({
+        date: JSON.stringify(dateFilter),
+        employee_id: JSON.stringify(employeeFilter),
+        limit: '1',
+      });
+
+      await this.apiRequest<InhouseBooking[]>(`?${params}`);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+}