@dynect/base 0.1.0 → 0.2.0

package/src/runtime/components/base/event-calendar/composables/useEventStore.ts

@@ -0,0 +1,325 @@
+import type { CalendarEvent } from '../types';
+import { usePerformanceCache } from './usePerformanceCache';
+
+interface EventStoreConfig {
+	maxEvents: number;
+	cacheTTL: number;
+	autoSync: boolean;
+	syncInterval: number;
+}
+
+interface EventOperation {
+	type: 'create' | 'update' | 'delete';
+	eventId: string;
+	event?: CalendarEvent;
+	timestamp: number;
+	userId?: string;
+}
+
+interface ConflictResolution {
+	strategy: 'latest' | 'merge' | 'manual';
+	onConflict?: (local: CalendarEvent, remote: CalendarEvent) => CalendarEvent;
+}
+
+/**
+ * Centralized event store with conflict resolution and offline support
+ */
+const defaultConfig: EventStoreConfig = {
+	maxEvents: 10000,
+	cacheTTL: 30 * 60 * 1000, // 30 minutes
+	autoSync: true,
+	syncInterval: 30000, // 30 seconds
+};
+
+export function useEventStore(config: EventStoreConfig = defaultConfig) {
+	const events = ref<Map<string, CalendarEvent>>(new Map());
+	const pendingOperations = ref<EventOperation[]>([]);
+	const lastSyncTime = ref<Date | null>(null);
+	const isOffline = ref(false);
+	const conflictResolver = ref<ConflictResolution>({ strategy: 'latest' });
+
+	const cache = usePerformanceCache<string, CalendarEvent[]>({
+		maxSize: 1000,
+		ttl: config.cacheTTL,
+		enabled: true,
+	});
+
+	// Convert map to array for reactive access
+	const eventsArray = computed(() => Array.from(events.value.values()));
+
+	const totalEvents = computed(() => events.value.size);
+
+	// Event operations
+	const addEvent = (event: CalendarEvent): void => {
+		if (!event.id) {
+			throw new Error('Event must have an id');
+		}
+
+		if (events.value.size >= config.maxEvents) {
+			throw new Error(`Maximum event limit (${config.maxEvents}) reached`);
+		}
+
+		events.value.set(event.id, { ...event });
+
+		// Track operation for sync
+		if (isOffline.value) {
+			pendingOperations.value.push({
+				type: 'create',
+				eventId: event.id,
+				event,
+				timestamp: Date.now(),
+			});
+		}
+
+		invalidateRelatedCaches(event);
+	};
+
+	const updateEvent = (eventId: string, updates: Partial<CalendarEvent>): boolean => {
+		const existingEvent = events.value.get(eventId);
+		if (!existingEvent) return false;
+
+		const updatedEvent = { ...existingEvent, ...updates, id: eventId };
+		events.value.set(eventId, updatedEvent);
+
+		// Track operation for sync
+		if (isOffline.value) {
+			pendingOperations.value.push({
+				type: 'update',
+				eventId,
+				event: updatedEvent,
+				timestamp: Date.now(),
+			});
+		}
+
+		invalidateRelatedCaches(updatedEvent);
+		return true;
+	};
+
+	const deleteEvent = (eventId: string): boolean => {
+		const existingEvent = events.value.get(eventId);
+		if (!existingEvent) return false;
+
+		events.value.delete(eventId);
+
+		// Track operation for sync
+		if (isOffline.value) {
+			pendingOperations.value.push({
+				type: 'delete',
+				eventId,
+				timestamp: Date.now(),
+			});
+		}
+
+		invalidateRelatedCaches(existingEvent);
+		return true;
+	};
+
+	const getEvent = (eventId: string): CalendarEvent | undefined => {
+		return events.value.get(eventId);
+	};
+
+	const getEventsInRange = (startDate: Date, endDate: Date): CalendarEvent[] => {
+		const cacheKey = `range-${startDate.toISOString()}-${endDate.toISOString()}`;
+
+		const cached = cache.get(cacheKey) as CalendarEvent[];
+		if (cached) {
+			return cached;
+		}
+
+		const filtered = eventsArray.value.filter((event) => {
+			const eventStart = new Date(event.startDate);
+			const eventEnd = new Date(event.endDate);
+			return eventStart <= endDate && eventEnd >= startDate;
+		});
+
+		cache.set(cacheKey, filtered);
+		return filtered;
+	};
+
+	const bulkUpdate = (updates: Array<{ id: string; updates: Partial<CalendarEvent> }>): void => {
+		const batchStart = Date.now();
+
+		updates.forEach(({ id, updates: eventUpdates }) => {
+			updateEvent(id, eventUpdates);
+		});
+
+		// Single cache invalidation for bulk operations
+		cache.clear();
+
+		console.log(`Bulk update completed: ${updates.length} events in ${Date.now() - batchStart}ms`);
+	};
+
+	// Conflict resolution
+	const resolveConflict = (localEvent: CalendarEvent, remoteEvent: CalendarEvent): CalendarEvent => {
+		switch (conflictResolver.value.strategy) {
+			case 'latest':
+				// Assume remote is always newer in this simple case
+				return remoteEvent;
+
+			case 'merge':
+				// Merge non-conflicting fields, prefer remote for conflicts
+				return {
+					...localEvent,
+					...remoteEvent,
+					// Keep local description if remote is empty
+					description: remoteEvent.description || localEvent.description,
+				};
+
+			case 'manual':
+				if (conflictResolver.value.onConflict) {
+					return conflictResolver.value.onConflict(localEvent, remoteEvent);
+				}
+				return remoteEvent;
+
+			default:
+				return remoteEvent;
+		}
+	};
+
+	// Sync with remote
+	const syncWithRemote = async (remoteEvents: CalendarEvent[]): Promise<void> => {
+		const conflicts: Array<{ local: CalendarEvent; remote: CalendarEvent }> = [];
+
+		// Process remote events
+		remoteEvents.forEach((remoteEvent) => {
+			if (!remoteEvent.id) return; // Skip events without an id
+
+			const localEvent = events.value.get(remoteEvent.id);
+
+			if (localEvent) {
+				// Check for conflicts (simple timestamp comparison)
+				const localTime = new Date(localEvent.endDate).getTime();
+				const remoteTime = new Date(remoteEvent.endDate).getTime();
+
+				if (Math.abs(localTime - remoteTime) > 1000) {
+					// 1 second tolerance
+					conflicts.push({ local: localEvent, remote: remoteEvent });
+				}
+			} else {
+				// New remote event
+				events.value.set(remoteEvent.id, remoteEvent);
+			}
+		});
+
+		// Resolve conflicts
+		conflicts.forEach(({ local, remote }) => {
+			const resolved = resolveConflict(local, remote);
+			if (resolved.id) {
+				events.value.set(resolved.id, resolved);
+			}
+		});
+
+		// Apply pending operations
+		await applyPendingOperations();
+
+		lastSyncTime.value = new Date();
+		cache.clear(); // Invalidate all caches after sync
+	};
+
+	const applyPendingOperations = async (): Promise<void> => {
+		// Sort by timestamp to apply in order
+		const sortedOps = [...pendingOperations.value].sort((a, b) => a.timestamp - b.timestamp);
+
+		for (const op of sortedOps) {
+			try {
+				// Here you would call your API
+				await simulateAPICall(op);
+			} catch (error) {
+				console.error('Failed to apply operation:', op, error);
+				// Keep failed operations for retry
+				continue;
+			}
+		}
+
+		// Clear successfully applied operations
+		pendingOperations.value = [];
+	};
+
+	const simulateAPICall = async (_operation: EventOperation): Promise<void> => {
+		// Simulate network delay
+		await new Promise((resolve) => setTimeout(resolve, 100));
+
+		// Simulate occasional failures
+		if (Math.random() < 0.1) {
+			throw new Error('Network error');
+		}
+	};
+
+	// Cache invalidation
+	const invalidateRelatedCaches = (_event: CalendarEvent): void => {
+		// Clear caches that might include this event
+		cache.clear(); // Simple approach - clear all
+		// In production, you'd be more selective about which caches to clear
+	};
+
+	// Pagination
+	const getEventsPaginated = (page: number = 1, limit: number = 100, filter?: (event: CalendarEvent) => boolean): { events: CalendarEvent[]; total: number; hasMore: boolean } => {
+		const allEvents = filter ? eventsArray.value.filter(filter) : eventsArray.value;
+		const startIndex = (page - 1) * limit;
+		const endIndex = startIndex + limit;
+
+		return {
+			events: allEvents.slice(startIndex, endIndex),
+			total: allEvents.length,
+			hasMore: endIndex < allEvents.length,
+		};
+	};
+
+	// Auto-sync setup
+	let syncInterval: ReturnType<typeof setInterval> | null = null;
+
+	if (config.autoSync && globalThis.window !== undefined) {
+		syncInterval = setInterval(async () => {
+			if (!isOffline.value && pendingOperations.value.length > 0) {
+				try {
+					await applyPendingOperations();
+				} catch (error) {
+					console.error('Auto-sync failed:', error);
+				}
+			}
+		}, config.syncInterval);
+	}
+
+	// Cleanup
+	const cleanup = (): void => {
+		if (syncInterval) {
+			clearInterval(syncInterval);
+		}
+		cache.cleanup();
+	};
+
+	// Network status tracking
+	const setOfflineStatus = (offline: boolean): void => {
+		isOffline.value = offline;
+	};
+
+	return {
+		// State
+		events: eventsArray,
+		totalEvents,
+		pendingOperations: readonly(pendingOperations),
+		lastSyncTime: readonly(lastSyncTime),
+		isOffline: readonly(isOffline),
+
+		// Operations
+		addEvent,
+		updateEvent,
+		deleteEvent,
+		getEvent,
+		getEventsInRange,
+		bulkUpdate,
+		getEventsPaginated,
+
+		// Sync
+		syncWithRemote,
+		setOfflineStatus,
+
+		// Configuration
+		setConflictResolver: (resolver: ConflictResolution) => {
+			conflictResolver.value = resolver;
+		},
+
+		// Cleanup
+		cleanup,
+	};
+}

package/src/runtime/components/base/event-calendar/composables/useExternalCalendar.ts

@@ -0,0 +1,340 @@
+import type { CalendarEvent } from '../types';
+
+export interface ExternalCalendarProvider {
+	id: string;
+	name: string;
+	icon: string;
+	color: string;
+	isAuthenticated: boolean;
+	isEnabled: boolean;
+}
+
+export interface ExternalCalendarConfig {
+	googleCalendar?: {
+		clientId?: string;
+		apiKey?: string;
+		scopes?: string[];
+	};
+	microsoftOutlook?: {
+		clientId?: string;
+		tenantId?: string;
+		scopes?: string[];
+	};
+}
+
+export interface SyncStatus {
+	isSync: boolean;
+	lastSyncTime?: Date;
+	syncErrors?: string[];
+	pendingChanges: number;
+}
+
+export function useExternalCalendar(config: ExternalCalendarConfig = {}) {
+	const syncStatus = ref<SyncStatus>({
+		isSync: false,
+		pendingChanges: 0,
+	});
+
+	const providers = ref<ExternalCalendarProvider[]>([
+		{
+			id: 'google',
+			name: 'Google Calendar',
+			icon: 'lucide:calendar',
+			color: '#4285F4',
+			isAuthenticated: false,
+			isEnabled: false,
+		},
+		{
+			id: 'outlook',
+			name: 'Microsoft Outlook',
+			icon: 'lucide:mail',
+			color: '#0078D4',
+			isAuthenticated: false,
+			isEnabled: false,
+		},
+	]);
+
+	// Google Calendar integration methods
+	const initializeGoogleCalendar = async () => {
+		if (!config.googleCalendar?.clientId || !config.googleCalendar?.apiKey) {
+			throw new Error('Google Calendar configuration is missing');
+		}
+
+		try {
+			// This would typically load the Google API client
+			// For now, we'll simulate the initialization
+			console.log('Initializing Google Calendar API...');
+
+			// In a real implementation, you would:
+			// 1. Load the Google API client library
+			// 2. Initialize the client with your API key and client ID
+			// 3. Set up authentication scopes
+
+			return {
+				success: true,
+				message: 'Google Calendar API initialized successfully',
+			};
+		} catch (error) {
+			console.error('Failed to initialize Google Calendar:', error);
+			throw error;
+		}
+	};
+
+	const authenticateGoogle = async () => {
+		try {
+			console.log('Authenticating with Google Calendar...');
+
+			// In a real implementation, you would:
+			// 1. Use Google's OAuth 2.0 flow
+			// 2. Request appropriate scopes (calendar.readonly, calendar.events)
+			// 3. Handle the authentication response
+			// 4. Store the access token securely
+
+			// Simulate authentication
+			const provider = providers.value.find((p) => p.id === 'google');
+			if (provider) {
+				provider.isAuthenticated = true;
+				provider.isEnabled = true;
+			}
+
+			return {
+				success: true,
+				accessToken: 'simulated_access_token',
+				refreshToken: 'simulated_refresh_token',
+			};
+		} catch (error) {
+			console.error('Google authentication failed:', error);
+			throw error;
+		}
+	};
+
+	const fetchGoogleEvents = async (startDate: Date, endDate: Date): Promise<CalendarEvent[]> => {
+		try {
+			console.log('Fetching Google Calendar events...');
+
+			// In a real implementation, you would:
+			// 1. Use the Google Calendar API to fetch events
+			// 2. Convert Google event format to your CalendarEvent format
+			// 3. Handle pagination for large result sets
+			// 4. Apply proper date filtering
+
+			// Simulate fetching events
+			const mockEvents: CalendarEvent[] = [
+				{
+					id: 'google_event_1',
+					title: 'Meeting from Google Calendar',
+					description: 'Imported from Google Calendar',
+					startDate: new Date(startDate.getTime() + 86400000), // +1 day
+					endDate: new Date(startDate.getTime() + 86400000 + 3600000), // +1 hour
+					allDay: false,
+					color: 'sky',
+					location: 'Conference Room A',
+					status: 'confirmed',
+					timezone: 'America/New_York',
+				},
+			];
+
+			return mockEvents;
+		} catch (error) {
+			console.error('Failed to fetch Google events:', error);
+			throw error;
+		}
+	};
+
+	// Microsoft Outlook integration methods
+	const initializeMicrosoftOutlook = async () => {
+		if (!config.microsoftOutlook?.clientId) {
+			throw new Error('Microsoft Outlook configuration is missing');
+		}
+
+		try {
+			console.log('Initializing Microsoft Graph API...');
+
+			// In a real implementation, you would:
+			// 1. Load the Microsoft Graph SDK
+			// 2. Initialize the client with your app registration details
+			// 3. Set up authentication scopes
+
+			return {
+				success: true,
+				message: 'Microsoft Graph API initialized successfully',
+			};
+		} catch (error) {
+			console.error('Failed to initialize Microsoft Outlook:', error);
+			throw error;
+		}
+	};
+
+	const authenticateMicrosoft = async () => {
+		try {
+			console.log('Authenticating with Microsoft Outlook...');
+
+			// In a real implementation, you would:
+			// 1. Use Microsoft's OAuth 2.0 flow (MSAL)
+			// 2. Request appropriate scopes (Calendars.Read, Calendars.ReadWrite)
+			// 3. Handle the authentication response
+			// 4. Store the access token securely
+
+			const provider = providers.value.find((p) => p.id === 'outlook');
+			if (provider) {
+				provider.isAuthenticated = true;
+				provider.isEnabled = true;
+			}
+
+			return {
+				success: true,
+				accessToken: 'simulated_access_token',
+				refreshToken: 'simulated_refresh_token',
+			};
+		} catch (error) {
+			console.error('Microsoft authentication failed:', error);
+			throw error;
+		}
+	};
+
+	const fetchOutlookEvents = async (startDate: Date, endDate: Date): Promise<CalendarEvent[]> => {
+		try {
+			console.log('Fetching Outlook calendar events...');
+
+			// In a real implementation, you would:
+			// 1. Use Microsoft Graph API to fetch events
+			// 2. Convert Outlook event format to your CalendarEvent format
+			// 3. Handle pagination and filtering
+
+			const mockEvents: CalendarEvent[] = [
+				{
+					id: 'outlook_event_1',
+					title: 'Team Standup from Outlook',
+					description: 'Imported from Microsoft Outlook',
+					startDate: new Date(startDate.getTime() + 172800000), // +2 days
+					endDate: new Date(startDate.getTime() + 172800000 + 1800000), // +30 minutes
+					allDay: false,
+					color: 'violet',
+					location: 'Microsoft Teams',
+					status: 'confirmed',
+					timezone: 'America/Los_Angeles',
+				},
+			];
+
+			return mockEvents;
+		} catch (error) {
+			console.error('Failed to fetch Outlook events:', error);
+			throw error;
+		}
+	};
+
+	// Generic sync methods
+	const syncExternalCalendars = async (localEvents: ComputedRef<CalendarEvent[]>, dateRange: { start: Date; end: Date }) => {
+		syncStatus.value.isSync = true;
+		const allExternalEvents: CalendarEvent[] = [];
+		const errors: string[] = [];
+
+		try {
+			// Sync Google Calendar
+			const googleProvider = providers.value.find((p) => p.id === 'google');
+			if (googleProvider?.isEnabled && googleProvider?.isAuthenticated) {
+				try {
+					const googleEvents = await fetchGoogleEvents(dateRange.start, dateRange.end);
+					allExternalEvents.push(...googleEvents);
+				} catch (error) {
+					errors.push(`Google Calendar sync failed: ${error}`);
+				}
+			}
+
+			// Sync Microsoft Outlook
+			const outlookProvider = providers.value.find((p) => p.id === 'outlook');
+			if (outlookProvider?.isEnabled && outlookProvider?.isAuthenticated) {
+				try {
+					const outlookEvents = await fetchOutlookEvents(dateRange.start, dateRange.end);
+					allExternalEvents.push(...outlookEvents);
+				} catch (error) {
+					errors.push(`Outlook Calendar sync failed: ${error}`);
+				}
+			}
+
+			syncStatus.value = {
+				isSync: false,
+				lastSyncTime: new Date(),
+				syncErrors: errors.length > 0 ? errors : undefined,
+				pendingChanges: 0,
+			};
+
+			return allExternalEvents;
+		} catch (error) {
+			syncStatus.value.isSync = false;
+			syncStatus.value.syncErrors = [`Sync failed: ${error}`];
+			throw error;
+		}
+	};
+
+	const disconnectProvider = (providerId: string) => {
+		const provider = providers.value.find((p) => p.id === providerId);
+		if (provider) {
+			provider.isAuthenticated = false;
+			provider.isEnabled = false;
+		}
+
+		// In a real implementation, you would:
+		// 1. Revoke the access tokens
+		// 2. Clear stored authentication data
+		// 3. Remove any cached external events
+	};
+
+	const enableProvider = async (providerId: string) => {
+		const provider = providers.value.find((p) => p.id === providerId);
+		if (!provider) {
+			throw new Error(`Provider ${providerId} not found`);
+		}
+
+		try {
+			if (providerId === 'google') {
+				await initializeGoogleCalendar();
+				await authenticateGoogle();
+			} else if (providerId === 'outlook') {
+				await initializeMicrosoftOutlook();
+				await authenticateMicrosoft();
+			}
+
+			provider.isEnabled = true;
+			return { success: true };
+		} catch (error) {
+			console.error(`Failed to enable provider ${providerId}:`, error);
+			throw error;
+		}
+	};
+
+	// Computed properties
+	const enabledProviders = computed(() => providers.value.filter((p) => p.isEnabled && p.isAuthenticated));
+
+	const hasActiveSync = computed(() => syncStatus.value.isSync);
+
+	const syncStatusText = computed(() => {
+		if (syncStatus.value.isSync) return 'Syncing...';
+		if (syncStatus.value.syncErrors && syncStatus.value.syncErrors.length > 0) {
+			return `Sync errors: ${syncStatus.value.syncErrors.length}`;
+		}
+		if (syncStatus.value.lastSyncTime) {
+			return `Last synced: ${syncStatus.value.lastSyncTime.toLocaleTimeString()}`;
+		}
+		return 'Not synced';
+	});
+
+	return {
+		providers,
+		syncStatus,
+		enabledProviders,
+		hasActiveSync,
+		syncStatusText,
+
+		// Methods
+		enableProvider,
+		disconnectProvider,
+		syncExternalCalendars,
+		initializeGoogleCalendar,
+		authenticateGoogle,
+		fetchGoogleEvents,
+		initializeMicrosoftOutlook,
+		authenticateMicrosoft,
+		fetchOutlookEvents,
+	};
+}