diff --git a/.claude/settings.local.json b/.claude/settings.local.json
index b8def76..2206350 100644
--- a/.claude/settings.local.json
+++ b/.claude/settings.local.json
@@ -1,12 +1,7 @@
{
"permissions": {
"allow": [
- "Bash(npm run build:*)",
- "WebSearch",
- "WebFetch(domain:web.dev)",
- "WebFetch(domain:caniuse.com)",
- "WebFetch(domain:blog.rasc.ch)",
- "WebFetch(domain:developer.chrome.com)"
+ "Bash(npm run build:*)"
],
"deny": [],
"ask": []
diff --git a/.workbench/event-colors.txt b/.workbench/event-colors.txt
deleted file mode 100644
index 8c07e65..0000000
--- a/.workbench/event-colors.txt
+++ /dev/null
@@ -1,147 +0,0 @@
-
-
-
-
-
- Event Farvesystem Demo
-
-
-
-
-Event Farvesystem Demo
-Baggrunden er dæmpet primærfarve, hover gør den mørkere, venstre kant og tekst bruger den rene farve.
-
-
-
-
-
-
-
-
-
-
Grøn event
-
.is-green
-
-
-
-
-
-
Magenta event
-
.is-magenta
-
-
-
-
-
-
Amber event
-
.is-amber
-
-
-
-
-
-
Orange event
-
.is-orange
-
-
-
-
`;
- } else {
- // Fallback: initials
- const initials = this.getInitials(resource.displayName);
- const bgColor = resource.color || '#6366f1';
- avatarHtml = `${initials}`;
- }
-
- header.innerHTML = `
-
- `;
-
- header.dataset.columnId = columnInfo.identifier;
- header.dataset.resourceId = resource.id;
- header.dataset.groupId = columnInfo.groupId;
-
- calendarHeader.appendChild(header);
- });
- }
-
- /**
- * Get initials from display name
- */
- private getInitials(name: string): string {
- return name
- .split(' ')
- .map(part => part.charAt(0))
- .join('')
- .toUpperCase()
- .substring(0, 2);
- }
-}
diff --git a/src/repositories/IEventRepository.ts b/src/repositories/IEventRepository.ts
new file mode 100644
index 0000000..da8e131
--- /dev/null
+++ b/src/repositories/IEventRepository.ts
@@ -0,0 +1,56 @@
+import { ICalendarEvent } from '../types/CalendarTypes';
+
+/**
+ * Update source type
+ * - 'local': Changes made by the user locally (needs sync)
+ * - 'remote': Changes from API/SignalR (already synced)
+ */
+export type UpdateSource = 'local' | 'remote';
+
+/**
+ * IEventRepository - Interface for event data access
+ *
+ * Abstracts the data source for calendar events, allowing easy switching
+ * between IndexedDB, REST API, GraphQL, or other data sources.
+ *
+ * Implementations:
+ * - IndexedDBEventRepository: Local storage with offline support
+ * - MockEventRepository: (Legacy) Loads from local JSON file
+ * - ApiEventRepository: (Future) Loads from backend API
+ */
+export interface IEventRepository {
+ /**
+ * Load all calendar events from the data source
+ * @returns Promise resolving to array of ICalendarEvent objects
+ * @throws Error if loading fails
+ */
+ loadEvents(): Promise;
+
+ /**
+ * Create a new event
+ * @param event - Event to create (without ID, will be generated)
+ * @param source - Source of the update ('local' or 'remote')
+ * @returns Promise resolving to the created event with generated ID
+ * @throws Error if creation fails
+ */
+ createEvent(event: Omit, source?: UpdateSource): Promise;
+
+ /**
+ * Update an existing event
+ * @param id - ID of the event to update
+ * @param updates - Partial event data to update
+ * @param source - Source of the update ('local' or 'remote')
+ * @returns Promise resolving to the updated event
+ * @throws Error if update fails or event not found
+ */
+ updateEvent(id: string, updates: Partial, source?: UpdateSource): Promise;
+
+ /**
+ * Delete an event
+ * @param id - ID of the event to delete
+ * @param source - Source of the update ('local' or 'remote')
+ * @returns Promise resolving when deletion is complete
+ * @throws Error if deletion fails or event not found
+ */
+ deleteEvent(id: string, source?: UpdateSource): Promise;
+}
diff --git a/src/repositories/IndexedDBEventRepository.ts b/src/repositories/IndexedDBEventRepository.ts
new file mode 100644
index 0000000..12193e0
--- /dev/null
+++ b/src/repositories/IndexedDBEventRepository.ts
@@ -0,0 +1,179 @@
+import { ICalendarEvent } from '../types/CalendarTypes';
+import { IEventRepository, UpdateSource } from './IEventRepository';
+import { IndexedDBService } from '../storage/IndexedDBService';
+import { EventService } from '../storage/events/EventService';
+import { OperationQueue } from '../storage/OperationQueue';
+
+/**
+ * IndexedDBEventRepository
+ * Offline-first repository using IndexedDB as single source of truth
+ *
+ * All CRUD operations:
+ * - Save to IndexedDB immediately via EventService (always succeeds)
+ * - Add to sync queue if source is 'local'
+ * - Background SyncManager processes queue to sync with API
+ */
+export class IndexedDBEventRepository implements IEventRepository {
+ private indexedDB: IndexedDBService;
+ private eventService: EventService;
+ private queue: OperationQueue;
+
+ constructor(indexedDB: IndexedDBService, queue: OperationQueue) {
+ this.indexedDB = indexedDB;
+ this.queue = queue;
+ // EventService will be initialized after IndexedDB is ready
+ this.eventService = null as any;
+ }
+
+ /**
+ * Ensure EventService is initialized with database connection
+ */
+ private ensureEventService(): void {
+ if (!this.eventService && this.indexedDB.isInitialized()) {
+ const db = (this.indexedDB as any).db; // Access private db property
+ this.eventService = new EventService(db);
+ }
+ }
+
+ /**
+ * Load all events from IndexedDB
+ * Ensures IndexedDB is initialized on first call
+ */
+ async loadEvents(): Promise {
+ // Lazy initialization on first data load
+ if (!this.indexedDB.isInitialized()) {
+ await this.indexedDB.initialize();
+ // TODO: Seeding should be done at application level, not here
+ }
+
+ this.ensureEventService();
+ return await this.eventService.getAll();
+ }
+
+ /**
+ * Create a new event
+ * - Generates ID
+ * - Saves to IndexedDB
+ * - Adds to queue if local (needs sync)
+ */
+ async createEvent(event: Omit, source: UpdateSource = 'local'): Promise {
+ // Generate unique ID
+ const id = this.generateEventId();
+
+ // Determine sync status based on source
+ const syncStatus = source === 'local' ? 'pending' : 'synced';
+
+ // Create full event object
+ const newEvent: ICalendarEvent = {
+ ...event,
+ id,
+ syncStatus
+ } as ICalendarEvent;
+
+ // Save to IndexedDB via EventService
+ this.ensureEventService();
+ await this.eventService.save(newEvent);
+
+ // If local change, add to sync queue
+ if (source === 'local') {
+ await this.queue.enqueue({
+ type: 'create',
+ entityId: id,
+ dataEntity: {
+ typename: 'Event',
+ data: newEvent
+ },
+ timestamp: Date.now(),
+ retryCount: 0
+ });
+ }
+
+ return newEvent;
+ }
+
+ /**
+ * Update an existing event
+ * - Updates in IndexedDB
+ * - Adds to queue if local (needs sync)
+ */
+ async updateEvent(id: string, updates: Partial, source: UpdateSource = 'local'): Promise {
+ // Get existing event via EventService
+ this.ensureEventService();
+ const existingEvent = await this.eventService.get(id);
+ if (!existingEvent) {
+ throw new Error(`Event with ID ${id} not found`);
+ }
+
+ // Determine sync status based on source
+ const syncStatus = source === 'local' ? 'pending' : 'synced';
+
+ // Merge updates
+ const updatedEvent: ICalendarEvent = {
+ ...existingEvent,
+ ...updates,
+ id, // Ensure ID doesn't change
+ syncStatus
+ };
+
+ // Save to IndexedDB via EventService
+ await this.eventService.save(updatedEvent);
+
+ // If local change, add to sync queue
+ if (source === 'local') {
+ await this.queue.enqueue({
+ type: 'update',
+ entityId: id,
+ dataEntity: {
+ typename: 'Event',
+ data: updates
+ },
+ timestamp: Date.now(),
+ retryCount: 0
+ });
+ }
+
+ return updatedEvent;
+ }
+
+ /**
+ * Delete an event
+ * - Removes from IndexedDB
+ * - Adds to queue if local (needs sync)
+ */
+ async deleteEvent(id: string, source: UpdateSource = 'local'): Promise {
+ // Check if event exists via EventService
+ this.ensureEventService();
+ const existingEvent = await this.eventService.get(id);
+ if (!existingEvent) {
+ throw new Error(`Event with ID ${id} not found`);
+ }
+
+ // If local change, add to sync queue BEFORE deleting
+ // (so we can send the delete operation to API later)
+ if (source === 'local') {
+ await this.queue.enqueue({
+ type: 'delete',
+ entityId: id,
+ dataEntity: {
+ typename: 'Event',
+ data: { id } // Minimal data for delete - just ID
+ },
+ timestamp: Date.now(),
+ retryCount: 0
+ });
+ }
+
+ // Delete from IndexedDB via EventService
+ await this.eventService.delete(id);
+ }
+
+ /**
+ * Generate unique event ID
+ * Format: {timestamp}-{random}
+ */
+ private generateEventId(): string {
+ const timestamp = Date.now();
+ const random = Math.random().toString(36).substring(2, 9);
+ return `${timestamp}-${random}`;
+ }
+}
diff --git a/src/repositories/MockAuditRepository.ts b/src/repositories/MockAuditRepository.ts
deleted file mode 100644
index 753f4b4..0000000
--- a/src/repositories/MockAuditRepository.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import { IApiRepository } from './IApiRepository';
-import { IAuditEntry } from '../types/AuditTypes';
-import { EntityType } from '../types/CalendarTypes';
-
-/**
- * MockAuditRepository - Mock API repository for audit entries
- *
- * In production, this would send audit entries to the backend.
- * For development/testing, it just logs the operations.
- */
-export class MockAuditRepository implements IApiRepository {
- readonly entityType: EntityType = 'Audit';
-
- async sendCreate(entity: IAuditEntry): Promise {
- // Simulate API call delay
- await new Promise(resolve => setTimeout(resolve, 100));
-
- console.log('MockAuditRepository: Audit entry synced to backend:', {
- id: entity.id,
- entityType: entity.entityType,
- entityId: entity.entityId,
- operation: entity.operation,
- timestamp: new Date(entity.timestamp).toISOString()
- });
-
- return entity;
- }
-
- async sendUpdate(_id: string, entity: IAuditEntry): Promise {
- // Audit entries are immutable - updates should not happen
- throw new Error('Audit entries cannot be updated');
- }
-
- async sendDelete(_id: string): Promise {
- // Audit entries should never be deleted
- throw new Error('Audit entries cannot be deleted');
- }
-
- async fetchAll(): Promise {
- // For now, return empty array - audit entries are local-first
- // In production, this could fetch audit history from backend
- return [];
- }
-
- async fetchById(_id: string): Promise {
- // For now, return null - audit entries are local-first
- return null;
- }
-}
diff --git a/src/repositories/MockBookingRepository.ts b/src/repositories/MockBookingRepository.ts
deleted file mode 100644
index 7637076..0000000
--- a/src/repositories/MockBookingRepository.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-import { IBooking, IBookingService, BookingStatus } from '../types/BookingTypes';
-import { EntityType } from '../types/CalendarTypes';
-import { IApiRepository } from './IApiRepository';
-
-interface RawBookingData {
- id: string;
- customerId: string;
- status: string;
- createdAt: string | Date;
- services: RawBookingService[];
- totalPrice?: number;
- tags?: string[];
- notes?: string;
- [key: string]: unknown;
-}
-
-interface RawBookingService {
- serviceId: string;
- serviceName: string;
- baseDuration: number;
- basePrice: number;
- customPrice?: number;
- resourceId: string;
-}
-
-/**
- * MockBookingRepository - Loads booking data from local JSON file
- *
- * This repository implementation fetches mock booking data from a static JSON file.
- * Used for development and testing instead of API calls.
- *
- * Data Source: data/mock-bookings.json
- *
- * NOTE: Create/Update/Delete operations are not supported - throws errors.
- * Only fetchAll() is implemented for loading initial mock data.
- */
-export class MockBookingRepository implements IApiRepository {
- public readonly entityType: EntityType = 'Booking';
- private readonly dataUrl = 'data/mock-bookings.json';
-
- /**
- * Fetch all bookings from mock JSON file
- */
- public async fetchAll(): Promise {
- try {
- const response = await fetch(this.dataUrl);
-
- if (!response.ok) {
- throw new Error(`Failed to load mock bookings: ${response.status} ${response.statusText}`);
- }
-
- const rawData: RawBookingData[] = await response.json();
-
- return this.processBookingData(rawData);
- } catch (error) {
- console.error('Failed to load booking data:', error);
- throw error;
- }
- }
-
- /**
- * NOT SUPPORTED - MockBookingRepository is read-only
- */
- public async sendCreate(booking: IBooking): Promise {
- throw new Error('MockBookingRepository does not support sendCreate. Mock data is read-only.');
- }
-
- /**
- * NOT SUPPORTED - MockBookingRepository is read-only
- */
- public async sendUpdate(id: string, updates: Partial): Promise {
- throw new Error('MockBookingRepository does not support sendUpdate. Mock data is read-only.');
- }
-
- /**
- * NOT SUPPORTED - MockBookingRepository is read-only
- */
- public async sendDelete(id: string): Promise {
- throw new Error('MockBookingRepository does not support sendDelete. Mock data is read-only.');
- }
-
- private processBookingData(data: RawBookingData[]): IBooking[] {
- return data.map((booking): IBooking => ({
- ...booking,
- createdAt: new Date(booking.createdAt),
- status: booking.status as BookingStatus,
- syncStatus: 'synced' as const
- }));
- }
-}
diff --git a/src/repositories/MockCustomerRepository.ts b/src/repositories/MockCustomerRepository.ts
deleted file mode 100644
index 8b5f71c..0000000
--- a/src/repositories/MockCustomerRepository.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-import { ICustomer } from '../types/CustomerTypes';
-import { EntityType } from '../types/CalendarTypes';
-import { IApiRepository } from './IApiRepository';
-
-interface RawCustomerData {
- id: string;
- name: string;
- phone: string;
- email?: string;
- metadata?: Record;
- [key: string]: unknown;
-}
-
-/**
- * MockCustomerRepository - Loads customer data from local JSON file
- *
- * This repository implementation fetches mock customer data from a static JSON file.
- * Used for development and testing instead of API calls.
- *
- * Data Source: data/mock-customers.json
- *
- * NOTE: Create/Update/Delete operations are not supported - throws errors.
- * Only fetchAll() is implemented for loading initial mock data.
- */
-export class MockCustomerRepository implements IApiRepository {
- public readonly entityType: EntityType = 'Customer';
- private readonly dataUrl = 'data/mock-customers.json';
-
- /**
- * Fetch all customers from mock JSON file
- */
- public async fetchAll(): Promise {
- try {
- const response = await fetch(this.dataUrl);
-
- if (!response.ok) {
- throw new Error(`Failed to load mock customers: ${response.status} ${response.statusText}`);
- }
-
- const rawData: RawCustomerData[] = await response.json();
-
- return this.processCustomerData(rawData);
- } catch (error) {
- console.error('Failed to load customer data:', error);
- throw error;
- }
- }
-
- /**
- * NOT SUPPORTED - MockCustomerRepository is read-only
- */
- public async sendCreate(customer: ICustomer): Promise {
- throw new Error('MockCustomerRepository does not support sendCreate. Mock data is read-only.');
- }
-
- /**
- * NOT SUPPORTED - MockCustomerRepository is read-only
- */
- public async sendUpdate(id: string, updates: Partial): Promise {
- throw new Error('MockCustomerRepository does not support sendUpdate. Mock data is read-only.');
- }
-
- /**
- * NOT SUPPORTED - MockCustomerRepository is read-only
- */
- public async sendDelete(id: string): Promise {
- throw new Error('MockCustomerRepository does not support sendDelete. Mock data is read-only.');
- }
-
- private processCustomerData(data: RawCustomerData[]): ICustomer[] {
- return data.map((customer): ICustomer => ({
- ...customer,
- syncStatus: 'synced' as const
- }));
- }
-}
diff --git a/src/repositories/MockEventRepository.ts b/src/repositories/MockEventRepository.ts
index 9740eb1..aa2c1e4 100644
--- a/src/repositories/MockEventRepository.ts
+++ b/src/repositories/MockEventRepository.ts
@@ -1,50 +1,33 @@
-import { ICalendarEvent, EntityType } from '../types/CalendarTypes';
+import { ICalendarEvent } from '../types/CalendarTypes';
import { CalendarEventType } from '../types/BookingTypes';
-import { IApiRepository } from './IApiRepository';
+import { IEventRepository, UpdateSource } from './IEventRepository';
interface RawEventData {
- // Core fields (required)
id: string;
title: string;
start: string | Date;
end: string | Date;
type: string;
+ color?: string;
allDay?: boolean;
-
- // Denormalized references (CRITICAL for booking architecture)
- bookingId?: string; // Reference to booking (customer events only)
- resourceId?: string; // Which resource owns this slot
- customerId?: string; // Customer reference (denormalized from booking)
-
- // Optional fields
- description?: string; // Detailed event notes
- recurringId?: string; // For recurring events
- metadata?: Record; // Flexible metadata
-
- // Legacy (deprecated, keep for backward compatibility)
- color?: string; // UI-specific field
[key: string]: unknown;
}
/**
- * MockEventRepository - Loads event data from local JSON file
+ * MockEventRepository - Loads event data from local JSON file (LEGACY)
*
* This repository implementation fetches mock event data from a static JSON file.
- * Used for development and testing instead of API calls.
+ * DEPRECATED: Use IndexedDBEventRepository for offline-first functionality.
*
* Data Source: data/mock-events.json
*
* NOTE: Create/Update/Delete operations are not supported - throws errors.
- * Only fetchAll() is implemented for loading initial mock data.
+ * This is intentional to encourage migration to IndexedDBEventRepository.
*/
-export class MockEventRepository implements IApiRepository {
- public readonly entityType: EntityType = 'Event';
+export class MockEventRepository implements IEventRepository {
private readonly dataUrl = 'data/mock-events.json';
- /**
- * Fetch all events from mock JSON file
- */
- public async fetchAll(): Promise {
+ public async loadEvents(): Promise {
try {
const response = await fetch(this.dataUrl);
@@ -63,60 +46,36 @@ export class MockEventRepository implements IApiRepository {
/**
* NOT SUPPORTED - MockEventRepository is read-only
+ * Use IndexedDBEventRepository instead
*/
- public async sendCreate(event: ICalendarEvent): Promise {
- throw new Error('MockEventRepository does not support sendCreate. Mock data is read-only.');
+ public async createEvent(event: Omit, source?: UpdateSource): Promise {
+ throw new Error('MockEventRepository does not support createEvent. Use IndexedDBEventRepository instead.');
}
/**
* NOT SUPPORTED - MockEventRepository is read-only
+ * Use IndexedDBEventRepository instead
*/
- public async sendUpdate(id: string, updates: Partial): Promise {
- throw new Error('MockEventRepository does not support sendUpdate. Mock data is read-only.');
+ public async updateEvent(id: string, updates: Partial, source?: UpdateSource): Promise {
+ throw new Error('MockEventRepository does not support updateEvent. Use IndexedDBEventRepository instead.');
}
/**
* NOT SUPPORTED - MockEventRepository is read-only
+ * Use IndexedDBEventRepository instead
*/
- public async sendDelete(id: string): Promise {
- throw new Error('MockEventRepository does not support sendDelete. Mock data is read-only.');
+ public async deleteEvent(id: string, source?: UpdateSource): Promise {
+ throw new Error('MockEventRepository does not support deleteEvent. Use IndexedDBEventRepository instead.');
}
private processCalendarData(data: RawEventData[]): ICalendarEvent[] {
- return data.map((event): ICalendarEvent => {
- // Validate event type constraints
- if (event.type === 'customer') {
- if (!event.bookingId) {
- console.warn(`Customer event ${event.id} missing bookingId`);
- }
- if (!event.resourceId) {
- console.warn(`Customer event ${event.id} missing resourceId`);
- }
- if (!event.customerId) {
- console.warn(`Customer event ${event.id} missing customerId`);
- }
- }
-
- return {
- id: event.id,
- title: event.title,
- description: event.description,
- start: new Date(event.start),
- end: new Date(event.end),
- type: event.type as CalendarEventType,
- allDay: event.allDay || false,
-
- // Denormalized references (CRITICAL for booking architecture)
- bookingId: event.bookingId,
- resourceId: event.resourceId,
- customerId: event.customerId,
-
- // Optional fields
- recurringId: event.recurringId,
- metadata: event.metadata,
-
- syncStatus: 'synced' as const
- };
- });
+ return data.map((event): ICalendarEvent => ({
+ ...event,
+ start: new Date(event.start),
+ end: new Date(event.end),
+ type: event.type as CalendarEventType,
+ allDay: event.allDay || false,
+ syncStatus: 'synced' as const
+ }));
}
}
diff --git a/src/repositories/MockResourceRepository.ts b/src/repositories/MockResourceRepository.ts
deleted file mode 100644
index 28bc838..0000000
--- a/src/repositories/MockResourceRepository.ts
+++ /dev/null
@@ -1,80 +0,0 @@
-import { IResource, ResourceType } from '../types/ResourceTypes';
-import { EntityType } from '../types/CalendarTypes';
-import { IApiRepository } from './IApiRepository';
-
-interface RawResourceData {
- id: string;
- name: string;
- displayName: string;
- type: string;
- avatarUrl?: string;
- color?: string;
- isActive?: boolean;
- metadata?: Record;
- [key: string]: unknown;
-}
-
-/**
- * MockResourceRepository - Loads resource data from local JSON file
- *
- * This repository implementation fetches mock resource data from a static JSON file.
- * Used for development and testing instead of API calls.
- *
- * Data Source: data/mock-resources.json
- *
- * NOTE: Create/Update/Delete operations are not supported - throws errors.
- * Only fetchAll() is implemented for loading initial mock data.
- */
-export class MockResourceRepository implements IApiRepository {
- public readonly entityType: EntityType = 'Resource';
- private readonly dataUrl = 'data/mock-resources.json';
-
- /**
- * Fetch all resources from mock JSON file
- */
- public async fetchAll(): Promise {
- try {
- const response = await fetch(this.dataUrl);
-
- if (!response.ok) {
- throw new Error(`Failed to load mock resources: ${response.status} ${response.statusText}`);
- }
-
- const rawData: RawResourceData[] = await response.json();
-
- return this.processResourceData(rawData);
- } catch (error) {
- console.error('Failed to load resource data:', error);
- throw error;
- }
- }
-
- /**
- * NOT SUPPORTED - MockResourceRepository is read-only
- */
- public async sendCreate(resource: IResource): Promise {
- throw new Error('MockResourceRepository does not support sendCreate. Mock data is read-only.');
- }
-
- /**
- * NOT SUPPORTED - MockResourceRepository is read-only
- */
- public async sendUpdate(id: string, updates: Partial): Promise {
- throw new Error('MockResourceRepository does not support sendUpdate. Mock data is read-only.');
- }
-
- /**
- * NOT SUPPORTED - MockResourceRepository is read-only
- */
- public async sendDelete(id: string): Promise {
- throw new Error('MockResourceRepository does not support sendDelete. Mock data is read-only.');
- }
-
- private processResourceData(data: RawResourceData[]): IResource[] {
- return data.map((resource): IResource => ({
- ...resource,
- type: resource.type as ResourceType,
- syncStatus: 'synced' as const
- }));
- }
-}
diff --git a/src/storage/BaseEntityService.ts b/src/storage/BaseEntityService.ts
index c889885..f7a8b12 100644
--- a/src/storage/BaseEntityService.ts
+++ b/src/storage/BaseEntityService.ts
@@ -1,10 +1,6 @@
-import { ISync, EntityType, SyncStatus, IEventBus } from '../types/CalendarTypes';
+import { ISync, EntityType, SyncStatus } from '../types/CalendarTypes';
import { IEntityService } from './IEntityService';
import { SyncPlugin } from './SyncPlugin';
-import { IndexedDBContext } from './IndexedDBContext';
-import { CoreEvents } from '../constants/CoreEvents';
-import { diff } from 'json-diff-ts';
-import { IEntitySavedPayload, IEntityDeletedPayload } from '../types/EventTypes';
/**
* BaseEntityService - Abstract base class for all entity services
@@ -17,7 +13,6 @@ import { IEntitySavedPayload, IEntityDeletedPayload } from '../types/EventTypes'
* - Generic CRUD operations (get, getAll, save, delete)
* - Sync status management (delegates to SyncPlugin)
* - Serialization hooks (override in subclass if needed)
- * - Lazy database access via IndexedDBContext
*
* SUBCLASSES MUST IMPLEMENT:
* - storeName: string (IndexedDB object store name)
@@ -32,7 +27,6 @@ import { IEntitySavedPayload, IEntityDeletedPayload } from '../types/EventTypes'
* - Type safety: Generic T ensures compile-time checking
* - Pluggable: SyncPlugin can be swapped for testing/different implementations
* - Open/Closed: New entities just extend this class
- * - Lazy database access: db requested when needed, not at construction time
*/
export abstract class BaseEntityService implements IEntityService {
// Abstract properties - must be implemented by subclasses
@@ -42,30 +36,17 @@ export abstract class BaseEntityService implements IEntityServi
// Internal composition - sync functionality
private syncPlugin: SyncPlugin;
- // IndexedDB context - provides database connection
- private context: IndexedDBContext;
-
- // EventBus for emitting entity events
- protected eventBus: IEventBus;
+ // Protected database instance - accessible to subclasses
+ protected db: IDBDatabase;
/**
- * @param context - IndexedDBContext instance (injected dependency)
- * @param eventBus - EventBus for emitting entity events
+ * @param db - IDBDatabase instance (injected dependency)
*/
- constructor(context: IndexedDBContext, eventBus: IEventBus) {
- this.context = context;
- this.eventBus = eventBus;
+ constructor(db: IDBDatabase) {
+ this.db = db;
this.syncPlugin = new SyncPlugin(this);
}
- /**
- * Get IDBDatabase instance (lazy access)
- * Protected getter accessible to subclasses and methods in this class
- */
- protected get db(): IDBDatabase {
- return this.context.getDatabase();
- }
-
/**
* Serialize entity before storing in IndexedDB
* Override in subclass if entity has Date fields or needs transformation
@@ -140,28 +121,10 @@ export abstract class BaseEntityService implements IEntityServi
/**
* Save an entity (create or update)
- * Emits ENTITY_SAVED event with operation type and changes
*
* @param entity - Entity to save
*/
async save(entity: T): Promise {
- const entityId = (entity as any).id;
-
- // Check if entity exists to determine create vs update
- const existingEntity = await this.get(entityId);
- const isCreate = existingEntity === null;
-
- // Calculate changes: full entity for create, diff for update
- let changes: any;
- if (isCreate) {
- changes = entity;
- } else {
- // Calculate diff between existing and new entity
- const existingSerialized = this.serialize(existingEntity);
- const newSerialized = this.serialize(entity);
- changes = diff(existingSerialized, newSerialized);
- }
-
const serialized = this.serialize(entity);
return new Promise((resolve, reject) => {
@@ -170,27 +133,17 @@ export abstract class BaseEntityService implements IEntityServi
const request = store.put(serialized);
request.onsuccess = () => {
- // Emit ENTITY_SAVED event
- const payload: IEntitySavedPayload = {
- entityType: this.entityType,
- entityId,
- operation: isCreate ? 'create' : 'update',
- changes,
- timestamp: Date.now()
- };
- this.eventBus.emit(CoreEvents.ENTITY_SAVED, payload);
resolve();
};
request.onerror = () => {
- reject(new Error(`Failed to save ${this.entityType} ${entityId}: ${request.error}`));
+ reject(new Error(`Failed to save ${this.entityType} ${(entity as any).id}: ${request.error}`));
};
});
}
/**
* Delete an entity
- * Emits ENTITY_DELETED event
*
* @param id - Entity ID to delete
*/
@@ -201,14 +154,6 @@ export abstract class BaseEntityService implements IEntityServi
const request = store.delete(id);
request.onsuccess = () => {
- // Emit ENTITY_DELETED event
- const payload: IEntityDeletedPayload = {
- entityType: this.entityType,
- entityId: id,
- operation: 'delete',
- timestamp: Date.now()
- };
- this.eventBus.emit(CoreEvents.ENTITY_DELETED, payload);
resolve();
};
diff --git a/src/storage/IEntityService.ts b/src/storage/IEntityService.ts
index c717598..692f8c3 100644
--- a/src/storage/IEntityService.ts
+++ b/src/storage/IEntityService.ts
@@ -4,13 +4,13 @@ import { ISync, EntityType, SyncStatus } from '../types/CalendarTypes';
* IEntityService - Generic interface for entity services with sync capabilities
*
* All entity services (Event, Booking, Customer, Resource) implement this interface
- * to enable polymorphic operations across different entity types.
+ * to enable polymorphic sync status management in SyncManager.
*
* ENCAPSULATION: Services encapsulate sync status manipulation.
* SyncManager does NOT directly manipulate entity.syncStatus - it delegates to the service.
*
- * POLYMORPHISM: Both SyncManager and DataSeeder work with Array>
- * and use entityType property for runtime routing, avoiding switch statements.
+ * POLYMORFI: SyncManager works with Array> and uses
+ * entityType property for runtime routing, avoiding switch statements.
*/
export interface IEntityService {
/**
@@ -19,30 +19,6 @@ export interface IEntityService {
*/
readonly entityType: EntityType;
- // ============================================================================
- // CRUD Operations (used by DataSeeder and other consumers)
- // ============================================================================
-
- /**
- * Get all entities from IndexedDB
- * Used by DataSeeder to check if store is empty before seeding
- *
- * @returns Promise - Array of all entities
- */
- getAll(): Promise;
-
- /**
- * Save an entity (create or update) to IndexedDB
- * Used by DataSeeder to persist fetched data
- *
- * @param entity - Entity to save
- */
- save(entity: T): Promise;
-
- // ============================================================================
- // SYNC Methods (used by SyncManager)
- // ============================================================================
-
/**
* Mark entity as successfully synced with backend
* Sets syncStatus = 'synced' and persists to IndexedDB
diff --git a/src/storage/IndexedDBContext.ts b/src/storage/IndexedDBContext.ts
deleted file mode 100644
index da2d6fe..0000000
--- a/src/storage/IndexedDBContext.ts
+++ /dev/null
@@ -1,128 +0,0 @@
-import { IStore } from './IStore';
-
-/**
- * IndexedDBContext - Database connection manager and provider
- *
- * RESPONSIBILITY:
- * - Opens and manages IDBDatabase connection lifecycle
- * - Creates object stores via injected IStore implementations
- * - Provides shared IDBDatabase instance to all services
- *
- * SEPARATION OF CONCERNS:
- * - This class: Connection management ONLY
- * - OperationQueue: Queue and sync state operations
- * - Entity Services: CRUD operations for specific entities
- *
- * USAGE:
- * Services inject IndexedDBContext and call getDatabase() to access db.
- * This lazy access pattern ensures db is ready when requested.
- */
-export class IndexedDBContext {
- private static readonly DB_NAME = 'CalendarDB';
- private static readonly DB_VERSION = 5; // Bumped to add syncStatus index to resources
- static readonly QUEUE_STORE = 'operationQueue';
- static readonly SYNC_STATE_STORE = 'syncState';
-
- private db: IDBDatabase | null = null;
- private initialized: boolean = false;
- private stores: IStore[];
-
- /**
- * @param stores - Array of IStore implementations injected via DI
- */
- constructor(stores: IStore[]) {
- this.stores = stores;
- }
-
- /**
- * Initialize and open the database
- * Creates all entity stores, queue store, and sync state store
- */
- async initialize(): Promise {
- return new Promise((resolve, reject) => {
- const request = indexedDB.open(IndexedDBContext.DB_NAME, IndexedDBContext.DB_VERSION);
-
- request.onerror = () => {
- reject(new Error(`Failed to open IndexedDB: ${request.error}`));
- };
-
- request.onsuccess = () => {
- this.db = request.result;
- this.initialized = true;
- resolve();
- };
-
- request.onupgradeneeded = (event) => {
- const db = (event.target as IDBOpenDBRequest).result;
-
- // Create all entity stores via injected IStore implementations
- // Open/Closed Principle: Adding new entity only requires DI registration
- this.stores.forEach(store => {
- if (!db.objectStoreNames.contains(store.storeName)) {
- store.create(db);
- }
- });
-
- // Create operation queue store (sync infrastructure)
- if (!db.objectStoreNames.contains(IndexedDBContext.QUEUE_STORE)) {
- const queueStore = db.createObjectStore(IndexedDBContext.QUEUE_STORE, { keyPath: 'id' });
- queueStore.createIndex('timestamp', 'timestamp', { unique: false });
- }
-
- // Create sync state store (sync metadata)
- if (!db.objectStoreNames.contains(IndexedDBContext.SYNC_STATE_STORE)) {
- db.createObjectStore(IndexedDBContext.SYNC_STATE_STORE, { keyPath: 'key' });
- }
- };
- });
- }
-
- /**
- * Check if database is initialized
- */
- public isInitialized(): boolean {
- return this.initialized;
- }
-
- /**
- * Get IDBDatabase instance
- * Used by services to access the database
- *
- * @throws Error if database not initialized
- * @returns IDBDatabase instance
- */
- public getDatabase(): IDBDatabase {
- if (!this.db) {
- throw new Error('IndexedDB not initialized. Call initialize() first.');
- }
- return this.db;
- }
-
- /**
- * Close database connection
- */
- close(): void {
- if (this.db) {
- this.db.close();
- this.db = null;
- this.initialized = false;
- }
- }
-
- /**
- * Delete entire database (for testing/reset)
- */
- static async deleteDatabase(): Promise {
- return new Promise((resolve, reject) => {
- const request = indexedDB.deleteDatabase(IndexedDBContext.DB_NAME);
-
- request.onsuccess = () => {
- resolve();
- };
-
- request.onerror = () => {
- reject(new Error(`Failed to delete database: ${request.error}`));
- };
- });
- }
-}
diff --git a/src/storage/IndexedDBService.ts b/src/storage/IndexedDBService.ts
new file mode 100644
index 0000000..28707d2
--- /dev/null
+++ b/src/storage/IndexedDBService.ts
@@ -0,0 +1,277 @@
+import { IDataEntity } from '../types/CalendarTypes';
+import { IStore } from './IStore';
+
+/**
+ * Operation for the sync queue
+ * Generic structure supporting all entity types (Event, Booking, Customer, Resource)
+ */
+export interface IQueueOperation {
+ id: string;
+ type: 'create' | 'update' | 'delete';
+ entityId: string;
+ dataEntity: IDataEntity;
+ timestamp: number;
+ retryCount: number;
+}
+
+/**
+ * IndexedDB Service for Calendar App
+ * Handles database connection management and core operations
+ *
+ * Entity-specific CRUD operations are handled by specialized services:
+ * - EventService for calendar events
+ * - BookingService for bookings
+ * - CustomerService for customers
+ * - ResourceService for resources
+ */
+export class IndexedDBService {
+ private static readonly DB_NAME = 'CalendarDB';
+ private static readonly DB_VERSION = 2;
+ private static readonly QUEUE_STORE = 'operationQueue';
+ private static readonly SYNC_STATE_STORE = 'syncState';
+
+ private db: IDBDatabase | null = null;
+ private initialized: boolean = false;
+ private stores: IStore[];
+
+ /**
+ * @param stores - Array of IStore implementations injected via DI
+ */
+ constructor(stores: IStore[]) {
+ this.stores = stores;
+ }
+
+ /**
+ * Initialize and open the database
+ */
+ async initialize(): Promise {
+ return new Promise((resolve, reject) => {
+ const request = indexedDB.open(IndexedDBService.DB_NAME, IndexedDBService.DB_VERSION);
+
+ request.onerror = () => {
+ reject(new Error(`Failed to open IndexedDB: ${request.error}`));
+ };
+
+ request.onsuccess = () => {
+ this.db = request.result;
+ this.initialized = true;
+ resolve();
+ };
+
+ request.onupgradeneeded = (event) => {
+ const db = (event.target as IDBOpenDBRequest).result;
+
+ // Create all entity stores via injected IStore implementations
+ // Open/Closed Principle: Adding new entity only requires DI registration
+ this.stores.forEach(store => {
+ if (!db.objectStoreNames.contains(store.storeName)) {
+ store.create(db);
+ }
+ });
+
+ // Create operation queue store (sync infrastructure)
+ if (!db.objectStoreNames.contains(IndexedDBService.QUEUE_STORE)) {
+ const queueStore = db.createObjectStore(IndexedDBService.QUEUE_STORE, { keyPath: 'id' });
+ queueStore.createIndex('timestamp', 'timestamp', { unique: false });
+ }
+
+ // Create sync state store (sync metadata)
+ if (!db.objectStoreNames.contains(IndexedDBService.SYNC_STATE_STORE)) {
+ db.createObjectStore(IndexedDBService.SYNC_STATE_STORE, { keyPath: 'key' });
+ }
+ };
+ });
+ }
+
+ /**
+ * Check if database is initialized
+ */
+ public isInitialized(): boolean {
+ return this.initialized;
+ }
+
+ /**
+ * Ensure database is initialized
+ */
+ private ensureDB(): IDBDatabase {
+ if (!this.db) {
+ throw new Error('IndexedDB not initialized. Call initialize() first.');
+ }
+ return this.db;
+ }
+
+ // ========================================
+ // Event CRUD Operations - MOVED TO EventService
+ // ========================================
+ // Event operations have been moved to storage/events/EventService.ts
+ // for better modularity and separation of concerns.
+
+ // ========================================
+ // Queue Operations
+ // ========================================
+
+ /**
+ * Add operation to queue
+ */
+ async addToQueue(operation: Omit): Promise {
+ const db = this.ensureDB();
+ const queueItem: IQueueOperation = {
+ ...operation,
+ id: `${operation.type}-${operation.entityId}-${Date.now()}`
+ };
+
+ return new Promise((resolve, reject) => {
+ const transaction = db.transaction([IndexedDBService.QUEUE_STORE], 'readwrite');
+ const store = transaction.objectStore(IndexedDBService.QUEUE_STORE);
+ const request = store.put(queueItem);
+
+ request.onsuccess = () => {
+ resolve();
+ };
+
+ request.onerror = () => {
+ reject(new Error(`Failed to add to queue: ${request.error}`));
+ };
+ });
+ }
+
+ /**
+ * Get all queue operations (sorted by timestamp)
+ */
+ async getQueue(): Promise {
+ const db = this.ensureDB();
+ return new Promise((resolve, reject) => {
+ const transaction = db.transaction([IndexedDBService.QUEUE_STORE], 'readonly');
+ const store = transaction.objectStore(IndexedDBService.QUEUE_STORE);
+ const index = store.index('timestamp');
+ const request = index.getAll();
+
+ request.onsuccess = () => {
+ resolve(request.result as IQueueOperation[]);
+ };
+
+ request.onerror = () => {
+ reject(new Error(`Failed to get queue: ${request.error}`));
+ };
+ });
+ }
+
+ /**
+ * Remove operation from queue
+ */
+ async removeFromQueue(id: string): Promise {
+ const db = this.ensureDB();
+ return new Promise((resolve, reject) => {
+ const transaction = db.transaction([IndexedDBService.QUEUE_STORE], 'readwrite');
+ const store = transaction.objectStore(IndexedDBService.QUEUE_STORE);
+ const request = store.delete(id);
+
+ request.onsuccess = () => {
+ resolve();
+ };
+
+ request.onerror = () => {
+ reject(new Error(`Failed to remove from queue: ${request.error}`));
+ };
+ });
+ }
+
+ /**
+ * Clear entire queue
+ */
+ async clearQueue(): Promise {
+ const db = this.ensureDB();
+ return new Promise((resolve, reject) => {
+ const transaction = db.transaction([IndexedDBService.QUEUE_STORE], 'readwrite');
+ const store = transaction.objectStore(IndexedDBService.QUEUE_STORE);
+ const request = store.clear();
+
+ request.onsuccess = () => {
+ resolve();
+ };
+
+ request.onerror = () => {
+ reject(new Error(`Failed to clear queue: ${request.error}`));
+ };
+ });
+ }
+
+ // ========================================
+ // Sync State Operations
+ // ========================================
+
+ /**
+ * Save sync state value
+ */
+ async setSyncState(key: string, value: any): Promise {
+ const db = this.ensureDB();
+ return new Promise((resolve, reject) => {
+ const transaction = db.transaction([IndexedDBService.SYNC_STATE_STORE], 'readwrite');
+ const store = transaction.objectStore(IndexedDBService.SYNC_STATE_STORE);
+ const request = store.put({ key, value });
+
+ request.onsuccess = () => {
+ resolve();
+ };
+
+ request.onerror = () => {
+ reject(new Error(`Failed to set sync state ${key}: ${request.error}`));
+ };
+ });
+ }
+
+ /**
+ * Get sync state value
+ */
+ async getSyncState(key: string): Promise {
+ const db = this.ensureDB();
+ return new Promise((resolve, reject) => {
+ const transaction = db.transaction([IndexedDBService.SYNC_STATE_STORE], 'readonly');
+ const store = transaction.objectStore(IndexedDBService.SYNC_STATE_STORE);
+ const request = store.get(key);
+
+ request.onsuccess = () => {
+ const result = request.result;
+ resolve(result ? result.value : null);
+ };
+
+ request.onerror = () => {
+ reject(new Error(`Failed to get sync state ${key}: ${request.error}`));
+ };
+ });
+ }
+
+ /**
+ * Close database connection
+ */
+ close(): void {
+ if (this.db) {
+ this.db.close();
+ this.db = null;
+ }
+ }
+
+ /**
+ * Delete entire database (for testing/reset)
+ */
+ static async deleteDatabase(): Promise {
+ return new Promise((resolve, reject) => {
+ const request = indexedDB.deleteDatabase(IndexedDBService.DB_NAME);
+
+ request.onsuccess = () => {
+ resolve();
+ };
+
+ request.onerror = () => {
+ reject(new Error(`Failed to delete database: ${request.error}`));
+ };
+ });
+ }
+
+ // ========================================
+ // Seeding - REMOVED
+ // ========================================
+ // seedIfEmpty() has been removed.
+ // Seeding should be implemented at application level using EventService,
+ // BookingService, CustomerService, and ResourceService directly.
+}
diff --git a/src/storage/OperationQueue.ts b/src/storage/OperationQueue.ts
new file mode 100644
index 0000000..7a822cf
--- /dev/null
+++ b/src/storage/OperationQueue.ts
@@ -0,0 +1,125 @@
+import { IndexedDBService, IQueueOperation } from './IndexedDBService';
+
+/**
+ * Operation Queue Manager
+ * Handles FIFO queue of pending sync operations
+ */
+export class OperationQueue {
+ private indexedDB: IndexedDBService;
+
+ constructor(indexedDB: IndexedDBService) {
+ this.indexedDB = indexedDB;
+ }
+
+ /**
+ * Add operation to the end of the queue
+ */
+ async enqueue(operation: Omit): Promise {
+ await this.indexedDB.addToQueue(operation);
+ }
+
+ /**
+ * Get the first operation from the queue (without removing it)
+ * Returns null if queue is empty
+ */
+ async peek(): Promise {
+ const queue = await this.indexedDB.getQueue();
+ return queue.length > 0 ? queue[0] : null;
+ }
+
+ /**
+ * Get all operations in the queue (sorted by timestamp FIFO)
+ */
+ async getAll(): Promise {
+ return await this.indexedDB.getQueue();
+ }
+
+ /**
+ * Remove a specific operation from the queue
+ */
+ async remove(operationId: string): Promise {
+ await this.indexedDB.removeFromQueue(operationId);
+ }
+
+ /**
+ * Remove the first operation from the queue and return it
+ * Returns null if queue is empty
+ */
+ async dequeue(): Promise {
+ const operation = await this.peek();
+ if (operation) {
+ await this.remove(operation.id);
+ }
+ return operation;
+ }
+
+ /**
+ * Clear all operations from the queue
+ */
+ async clear(): Promise {
+ await this.indexedDB.clearQueue();
+ }
+
+ /**
+ * Get the number of operations in the queue
+ */
+ async size(): Promise {
+ const queue = await this.getAll();
+ return queue.length;
+ }
+
+ /**
+ * Check if queue is empty
+ */
+ async isEmpty(): Promise {
+ const size = await this.size();
+ return size === 0;
+ }
+
+ /**
+ * Get operations for a specific entity ID
+ */
+ async getOperationsForEntity(entityId: string): Promise