zyflow 0.6.4

package/src/stores/errorStore.ts

@@ -0,0 +1,301 @@
+/**
+ * Global Error Store (Zustand)
+ * Manages global error state with deduplication, prioritization, and persistence
+ * @module stores/errorStore
+ */
+
+import { create } from 'zustand'
+import { ErrorContext, ErrorSeverity, ErrorType } from '@/types/errors'
+import { getErrorLogger } from '@/utils/error-logger'
+
+// =============================================
+// Store State Interface
+// =============================================
+
+export interface ErrorStoreState {
+  // Active errors displayed to user
+  activeErrors: ErrorContext[]
+
+  // All error history
+  history: ErrorContext[]
+
+  // Queued errors waiting to be displayed
+  queue: ErrorContext[]
+
+  // Deduplication map for preventing toast spam
+  deduplicationMap: Map<string, ErrorContext>
+
+  // Store state
+  isInitialized: boolean
+  maxActiveErrors: number
+  maxHistorySize: number
+}
+
+export interface ErrorStoreActions {
+  // Add error
+  addError: (error: ErrorContext) => void
+
+  // Clear specific error
+  clearError: (id: string) => void
+
+  // Clear all errors
+  clearAll: () => void
+
+  // Get errors
+  getErrors: (filter?: {
+    type?: ErrorType
+    severity?: ErrorSeverity
+    component?: string
+  }) => ErrorContext[]
+
+  // Get error by code
+  getErrorByCode: (code: string) => ErrorContext | undefined
+
+  // Mark error as read/handled
+  markAsHandled: (id: string) => void
+
+  // Process queue (move queued errors to active)
+  processQueue: () => void
+
+  // Get deduplication key
+  getDeduplicationKey: (error: ErrorContext) => string
+
+  // Initialize store
+  initialize: () => void
+
+  // Export errors
+  exportErrors: () => ErrorContext[]
+}
+
+export type ErrorStore = ErrorStoreState & ErrorStoreActions
+
+// =============================================
+// Helper Functions
+// =============================================
+
+/**
+ * Create a unique ID for error context
+ */
+function createErrorId(): string {
+  return `error_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+}
+
+/**
+ * Get deduplication key for error
+ */
+function getDeduplicationKey(error: ErrorContext): string {
+  const { code, component, function: fn } = error
+  return `${code}::${component || 'unknown'}::${fn || 'unknown'}`
+}
+
+/**
+ * Check if errors are identical (for deduplication)
+ */
+function areErrorsIdentical(error1: ErrorContext, error2: ErrorContext): boolean {
+  return (
+    error1.code === error2.code &&
+    error1.component === error2.component &&
+    error1.function === error2.function
+  )
+}
+
+/**
+ * Sort errors by severity for prioritization
+ */
+function sortBySeverity(errors: ErrorContext[]): ErrorContext[] {
+  const severityOrder = {
+    [ErrorSeverity.CRITICAL]: 0,
+    [ErrorSeverity.ERROR]: 1,
+    [ErrorSeverity.WARNING]: 2,
+    [ErrorSeverity.INFO]: 3,
+  }
+
+  return [...errors].sort(
+    (a, b) => severityOrder[a.severity] - severityOrder[b.severity]
+  )
+}
+
+// =============================================
+// Zustand Store
+// =============================================
+
+export const useErrorStore = create<ErrorStore>((set, get) => ({
+  // Initial state
+  activeErrors: [],
+  history: [],
+  queue: [],
+  deduplicationMap: new Map(),
+  isInitialized: false,
+  maxActiveErrors: 3,
+  maxHistorySize: 100,
+
+  // Initialize store
+  initialize: () => {
+    set({ isInitialized: true })
+  },
+
+  // Add error
+  addError: (error: ErrorContext) => {
+    const state = get()
+    const deduplicationKey = getDeduplicationKey(error)
+
+    // Check for duplicates
+    const existingError = state.deduplicationMap.get(deduplicationKey)
+    if (existingError) {
+      // Update deduplication count
+      existingError.count = (existingError.count || 1) + 1
+      existingError.lastOccurrence = Date.now()
+
+      // Move to front if active
+      set((prev) => ({
+        activeErrors: [
+          existingError,
+          ...prev.activeErrors.filter((e) => getDeduplicationKey(e) !== deduplicationKey),
+        ],
+      }))
+
+      return
+    }
+
+    // Log error to logger
+    getErrorLogger().log(error)
+
+    // Determine if we should add to active or queue
+    const newActive = [error, ...state.activeErrors]
+    const sorted = sortBySeverity(newActive)
+
+    // Split into active and queued
+    const maxActive = state.maxActiveErrors
+    const activeErrors = sorted.slice(0, maxActive)
+    const queue = sorted.slice(maxActive)
+
+    // Update deduplication map
+    const newDeduplicationMap = new Map(state.deduplicationMap)
+    newDeduplicationMap.set(deduplicationKey, error)
+
+    // Maintain deduplication map size
+    if (newDeduplicationMap.size > state.maxHistorySize) {
+      const entries = Array.from(newDeduplicationMap.entries())
+      const oldestEntry = entries[0]
+      newDeduplicationMap.delete(oldestEntry[0])
+    }
+
+    set((prev) => ({
+      activeErrors,
+      queue,
+      deduplicationMap: newDeduplicationMap,
+      history: [error, ...prev.history].slice(0, state.maxHistorySize),
+    }))
+  },
+
+  // Clear specific error
+  clearError: (id: string) => {
+    set((prev) => ({
+      activeErrors: prev.activeErrors.filter((e) => createErrorId() !== id),
+    }))
+  },
+
+  // Clear all errors
+  clearAll: () => {
+    set({
+      activeErrors: [],
+      queue: [],
+      deduplicationMap: new Map(),
+    })
+  },
+
+  // Get errors with filter
+  getErrors: (filter) => {
+    const state = get()
+    let errors = [...state.activeErrors, ...state.queue]
+
+    if (filter?.type) {
+      errors = errors.filter((e) => e.type === filter.type)
+    }
+    if (filter?.severity) {
+      errors = errors.filter((e) => e.severity === filter.severity)
+    }
+    if (filter?.component) {
+      errors = errors.filter((e) => e.component === filter.component)
+    }
+
+    return errors
+  },
+
+  // Get error by code
+  getErrorByCode: (code: string) => {
+    const state = get()
+    return state.activeErrors.find((e) => e.code === code)
+  },
+
+  // Mark error as handled
+  markAsHandled: (id: string) => {
+    // Implementation for tracking handled errors
+    // Can be used for analytics
+  },
+
+  // Process queue
+  processQueue: () => {
+    const state = get()
+    if (state.queue.length === 0) return
+
+    const maxActive = state.maxActiveErrors
+    const newActive = [
+      ...state.activeErrors,
+      ...state.queue.slice(0, Math.max(0, maxActive - state.activeErrors.length)),
+    ]
+    const remainingQueue = state.queue.slice(Math.max(0, maxActive - state.activeErrors.length))
+
+    set({
+      activeErrors: sortBySeverity(newActive),
+      queue: remainingQueue,
+    })
+  },
+
+  // Get deduplication key
+  getDeduplicationKey: (error: ErrorContext) => {
+    return getDeduplicationKey(error)
+  },
+
+  // Export errors
+  exportErrors: () => {
+    const state = get()
+    return [
+      ...state.activeErrors,
+      ...state.queue,
+      ...state.history,
+    ]
+  },
+}))
+
+// =============================================
+// Selectors
+// =============================================
+
+export const selectActiveErrors = (state: ErrorStore) => state.activeErrors
+export const selectErrorHistory = (state: ErrorStore) => state.history
+export const selectErrorQueue = (state: ErrorStore) => state.queue
+export const selectErrorCount = (state: ErrorStore) => state.activeErrors.length
+export const selectHasCriticalErrors = (state: ErrorStore) =>
+  state.activeErrors.some((e) => e.severity === ErrorSeverity.CRITICAL)
+export const selectHasErrors = (state: ErrorStore) => state.activeErrors.length > 0
+
+// =============================================
+// Hooks for common operations
+// =============================================
+
+export function useErrorStore_addError(error: ErrorContext): void {
+  useErrorStore.getState().addError(error)
+}
+
+export function useErrorStore_clearAll(): void {
+  useErrorStore.getState().clearAll()
+}
+
+export function useErrorStore_getErrors(filter?: {
+  type?: ErrorType
+  severity?: ErrorSeverity
+  component?: string
+}): ErrorContext[] {
+  return useErrorStore.getState().getErrors(filter)
+}

package/src/stores/offlineStore.ts

@@ -0,0 +1,266 @@
+/**
+ * Offline Mode Store (Zustand)
+ *
+ * Manages offline state, queued operations, and synchronization
+ * @module stores/offlineStore
+ */
+
+import { create } from 'zustand'
+import { nanoid } from 'nanoid'
+
+// =============================================
+// Types
+// =============================================
+
+export type QueuedOperationType = 'create' | 'update' | 'delete' | 'patch'
+
+export interface QueuedOperation {
+  id: string
+  type: QueuedOperationType
+  endpoint: string
+  method: string
+  body?: unknown
+  timestamp: number
+  retryCount: number
+  lastError?: string
+}
+
+export interface OfflineStoreState {
+  // Online/offline state
+  isOnline: boolean
+  lastOnlineTime: number
+  lastOfflineTime: number
+
+  // Queued operations
+  queue: QueuedOperation[]
+
+  // Sync state
+  isSyncing: boolean
+  syncProgress: {
+    completed: number
+    total: number
+  }
+  lastSyncTime?: number
+  lastSyncError?: string
+
+  // Settings
+  maxQueueSize: number
+  maxRetries: number
+}
+
+export interface OfflineStoreActions {
+  // Online/offline management
+  setOnline: (isOnline: boolean) => void
+
+  // Queue operations
+  addToQueue: (
+    operation: Omit<QueuedOperation, 'id' | 'timestamp' | 'retryCount'>
+  ) => string
+  removeFromQueue: (id: string) => void
+  getQueuedOperation: (id: string) => QueuedOperation | undefined
+  getAllQueued: () => QueuedOperation[]
+  getQueuedByEndpoint: (endpoint: string) => QueuedOperation[]
+
+  // Sync operations
+  setSyncing: (isSyncing: boolean) => void
+  updateSyncProgress: (completed: number, total: number) => void
+  setSyncError: (error: string | undefined) => void
+  markSyncComplete: () => void
+
+  // Retry management
+  incrementRetryCount: (id: string) => void
+  setOperationError: (id: string, error: string) => void
+
+  // Clear operations
+  clearQueue: () => void
+  clearExpiredOperations: (maxAgeMs: number) => number
+
+  // Export
+  exportQueue: () => QueuedOperation[]
+}
+
+export type OfflineStore = OfflineStoreState & OfflineStoreActions
+
+// =============================================
+// Zustand Store
+// =============================================
+
+export const useOfflineStore = create<OfflineStore>((set, get) => ({
+  // Initial state
+  isOnline: true,
+  lastOnlineTime: Date.now(),
+  lastOfflineTime: 0,
+  queue: [],
+  isSyncing: false,
+  syncProgress: { completed: 0, total: 0 },
+  maxQueueSize: 100,
+  maxRetries: 5,
+
+  // Set online/offline
+  setOnline: (isOnline: boolean) => {
+    const now = Date.now()
+    set((state) => ({
+      isOnline,
+      lastOnlineTime: isOnline ? now : state.lastOnlineTime,
+      lastOfflineTime: !isOnline ? now : state.lastOfflineTime,
+    }))
+  },
+
+  // Add to queue
+  addToQueue: (operation) => {
+    const id = nanoid()
+    const newOperation: QueuedOperation = {
+      ...operation,
+      id,
+      timestamp: Date.now(),
+      retryCount: 0,
+    }
+
+    set((state) => {
+      // Check queue size limit
+      if (state.queue.length >= state.maxQueueSize) {
+        console.warn('Queue is full, removing oldest operation')
+        return {
+          queue: [...state.queue.slice(1), newOperation],
+        }
+      }
+
+      return {
+        queue: [...state.queue, newOperation],
+      }
+    })
+
+    return id
+  },
+
+  // Remove from queue
+  removeFromQueue: (id: string) => {
+    set((state) => ({
+      queue: state.queue.filter((op) => op.id !== id),
+    }))
+  },
+
+  // Get queued operation
+  getQueuedOperation: (id: string) => {
+    const state = get()
+    return state.queue.find((op) => op.id === id)
+  },
+
+  // Get all queued
+  getAllQueued: () => {
+    return get().queue
+  },
+
+  // Get queued by endpoint
+  getQueuedByEndpoint: (endpoint: string) => {
+    return get().queue.filter((op) => op.endpoint === endpoint)
+  },
+
+  // Set syncing state
+  setSyncing: (isSyncing: boolean) => {
+    set({ isSyncing })
+  },
+
+  // Update sync progress
+  updateSyncProgress: (completed: number, total: number) => {
+    set({
+      syncProgress: { completed, total },
+    })
+  },
+
+  // Set sync error
+  setSyncError: (error: string | undefined) => {
+    set({
+      lastSyncError: error,
+    })
+  },
+
+  // Mark sync complete
+  markSyncComplete: () => {
+    set({
+      isSyncing: false,
+      lastSyncTime: Date.now(),
+      lastSyncError: undefined,
+      syncProgress: { completed: 0, total: 0 },
+    })
+  },
+
+  // Increment retry count
+  incrementRetryCount: (id: string) => {
+    set((state) => ({
+      queue: state.queue.map((op) =>
+        op.id === id ? { ...op, retryCount: op.retryCount + 1 } : op
+      ),
+    }))
+  },
+
+  // Set operation error
+  setOperationError: (id: string, error: string) => {
+    set((state) => ({
+      queue: state.queue.map((op) =>
+        op.id === id ? { ...op, lastError: error } : op
+      ),
+    }))
+  },
+
+  // Clear queue
+  clearQueue: () => {
+    set({ queue: [] })
+  },
+
+  // Clear expired operations
+  clearExpiredOperations: (maxAgeMs: number) => {
+    const cutoffTime = Date.now() - maxAgeMs
+    const state = get()
+    const beforeCount = state.queue.length
+
+    set({
+      queue: state.queue.filter((op) => op.timestamp > cutoffTime),
+    })
+
+    return beforeCount - get().queue.length
+  },
+
+  // Export queue
+  exportQueue: () => {
+    return [...get().queue]
+  },
+}))
+
+// =============================================
+// Selectors
+// =============================================
+
+export const selectIsOnline = (state: OfflineStore) => state.isOnline
+export const selectIsOffline = (state: OfflineStore) => !state.isOnline
+export const selectQueue = (state: OfflineStore) => state.queue
+export const selectQueueLength = (state: OfflineStore) => state.queue.length
+export const selectQueueSize = (state: OfflineStore) => state.maxQueueSize
+export const selectIsSyncing = (state: OfflineStore) => state.isSyncing
+export const selectSyncProgress = (state: OfflineStore) => state.syncProgress
+export const selectLastSyncTime = (state: OfflineStore) => state.lastSyncTime
+export const selectLastSyncError = (state: OfflineStore) => state.lastSyncError
+export const selectHasQueuedOperations = (state: OfflineStore) =>
+  state.queue.length > 0
+
+// =============================================
+// Helper Hooks
+// =============================================
+
+export function useOfflineStore_addToQueue(
+  operation: Omit<QueuedOperation, 'id' | 'timestamp' | 'retryCount'>
+): string {
+  return useOfflineStore.getState().addToQueue(operation)
+}
+
+export function useOfflineStore_setOnline(isOnline: boolean): void {
+  useOfflineStore.getState().setOnline(isOnline)
+}
+
+export function useOfflineStore_getQueue(): QueuedOperation[] {
+  return useOfflineStore.getState().getAllQueued()
+}
+
+export function useOfflineStore_syncComplete(): void {
+  useOfflineStore.getState().markSyncComplete()
+}