Refactor entity services with hybrid sync pattern

Introduces BaseEntityService and SyncPlugin to eliminate code duplication across entity services

Improves:
- Code reusability through inheritance and composition
- Sync infrastructure for all entity types
- Polymorphic sync status management
- Reduced boilerplate code by ~75%

Supports generic sync for Event, Booking, Customer, and Resource entities

src/storage/SyncPlugin.ts

@@ -0,0 +1,90 @@
+import { ISync, SyncStatus, EntityType } from '../types/CalendarTypes';
+
+/**
+ * SyncPlugin<T extends ISync> - Pluggable sync functionality for entity services
+ *
+ * COMPOSITION PATTERN:
+ * - Encapsulates all sync-related logic in separate class
+ * - Composed into BaseEntityService (not inheritance)
+ * - Allows sync functionality to be swapped/mocked for testing
+ * - Single Responsibility: Only handles sync status management
+ *
+ * DESIGN:
+ * - Takes reference to BaseEntityService for calling get/save
+ * - Implements sync methods that delegate to service's CRUD
+ * - Uses IndexedDB syncStatus index for efficient queries
+ */
+export class SyncPlugin<T extends ISync> {
+  /**
+   * @param service - Reference to BaseEntityService for CRUD operations
+   */
+  constructor(private service: any) {
+    // Type is 'any' to avoid circular dependency at compile time
+    // Runtime: service is BaseEntityService<T>
+  }
+
+  /**
+   * Mark entity as successfully synced
+   * Sets syncStatus = 'synced' and persists to IndexedDB
+   *
+   * @param id - Entity ID
+   */
+  async markAsSynced(id: string): Promise<void> {
+    const entity = await this.service.get(id);
+    if (entity) {
+      entity.syncStatus = 'synced';
+      await this.service.save(entity);
+    }
+  }
+
+  /**
+   * Mark entity as sync error (max retries exceeded)
+   * Sets syncStatus = 'error' and persists to IndexedDB
+   *
+   * @param id - Entity ID
+   */
+  async markAsError(id: string): Promise<void> {
+    const entity = await this.service.get(id);
+    if (entity) {
+      entity.syncStatus = 'error';
+      await this.service.save(entity);
+    }
+  }
+
+  /**
+   * Get current sync status for an entity
+   *
+   * @param id - Entity ID
+   * @returns SyncStatus or null if entity not found
+   */
+  async getSyncStatus(id: string): Promise<SyncStatus | null> {
+    const entity = await this.service.get(id);
+    return entity ? entity.syncStatus : null;
+  }
+
+  /**
+   * Get entities by sync status
+   * Uses IndexedDB syncStatus index for efficient querying
+   *
+   * @param syncStatus - Sync status ('synced', 'pending', 'error')
+   * @returns Array of entities with this sync status
+   */
+  async getBySyncStatus(syncStatus: string): Promise<T[]> {
+    return new Promise((resolve, reject) => {
+      const transaction = this.service.db.transaction([this.service.storeName], 'readonly');
+      const store = transaction.objectStore(this.service.storeName);
+      const index = store.index('syncStatus');
+      const request = index.getAll(syncStatus);
+
+      request.onsuccess = () => {
+        const data = request.result as any[];
+        const entities = data.map(item => this.service.deserialize(item));
+        resolve(entities);
+      };
+
+      request.onerror = () => {
+        reject(new Error(`Failed to get ${this.service.entityType}s by sync status ${syncStatus}: ${request.error}`));
+      };
+    });
+  }
+}