@umituz/web-dashboard 3.2.2 → 4.0.0

package/src/domains/auth/utils/secureToken.ts

@@ -0,0 +1,33 @@
+/**
+ * Auth Utilities - Secure Token
+ *
+ * Cryptographically secure token generation utilities
+ */
+
+/**
+ * Generate a cryptographically secure random token.
+ *
+ * Requires the Web Crypto API (`crypto.getRandomValues`), available in
+ * all modern browsers, Node.js >= 19 (and >= 15 via `globalThis.crypto`),
+ * and React Native with a crypto polyfill. Throws instead of silently
+ * degrading to an insecure PRNG — predictable tokens are worse than
+ * a loud failure.
+ *
+ * @param length - Token length in bytes (default: 32)
+ * @returns Hex-encoded random token
+ * @throws Error when no CSPRNG is available in the runtime
+ */
+export function generateResetToken(length: number = 32): string {
+  if (typeof crypto === 'undefined' || typeof crypto.getRandomValues !== 'function') {
+    throw new Error(
+      'generateResetToken: no cryptographic random source available in this runtime ' +
+        '(requires crypto.getRandomValues — Web Crypto, Node >= 19, or a polyfill)',
+    );
+  }
+
+  const byteLength = Math.max(1, Math.floor(length));
+  const bytes = new Uint8Array(byteLength);
+  crypto.getRandomValues(bytes);
+
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+}

package/src/domains/auth/utils/validationKeys.ts

@@ -0,0 +1,23 @@
+/**
+ * Auth Validation Error Keys
+ *
+ * Stable i18n keys for validation errors. The auth UI maps these to
+ * localized messages via the consumer's translation system.
+ *
+ * Why keys instead of literal strings:
+ *   - No hardcoded user-facing strings in source code
+ *   - Centralized catalog: easier to audit and translate
+ *   - Validators stay pure and testable
+ */
+
+export const AUTH_VALIDATION_KEYS = {
+  emailRequired: 'auth.validation.emailRequired',
+  emailInvalid: 'auth.validation.emailInvalid',
+  passwordRequired: 'auth.validation.passwordRequired',
+  passwordTooShort: 'auth.validation.passwordTooShort',
+  passwordsDoNotMatch: 'auth.validation.passwordsDoNotMatch',
+  nameRequired: 'auth.validation.nameRequired',
+  invalidResetToken: 'auth.validation.invalidResetToken',
+} as const;
+
+export type AuthValidationKey = (typeof AUTH_VALIDATION_KEYS)[keyof typeof AUTH_VALIDATION_KEYS];

package/src/domains/calendar/hooks/useCalendar.ts

@@ -1,25 +1,36 @@
 /**
- * useCalendar Hook
+ * useCalendar
  *
- * React hook for calendar functionality with config support
+ * React hook for the calendar domain. Delegates persistence
+ * to the injected `CalendarService`, guards refreshes with a
+ * request id so a stale response can never overwrite a newer one,
+ * and returns a clean discriminated CRUD contract.
  */
 
-import { useState, useCallback, useEffect, useMemo } from 'react';
-import type { CalendarConfig, ContentItem, CalendarFilter } from '../types/calendar.types';
-import { calendarService } from '../services';
+import { useState, useCallback, useEffect, useMemo, useRef } from 'react';
+import type {
+  CalendarConfig,
+  ContentItem,
+  CalendarFilter,
+} from '../types/calendar.types';
+import { calendarService, applyCalendarFilter } from '../services';
 import { DEFAULT_CALENDAR_CONFIG } from '../utils';
+import type { ICalendarService } from '../types/calendar.types';
 
-interface UseCalendarOptions {
-  /** Calendar configuration */
+type CalendarView = 'month' | 'week' | 'day' | 'timeline';
+
+export interface UseCalendarOptions {
+  /** Calendar configuration overrides */
   config?: Partial<CalendarConfig>;
-  /** User ID */
+  /** User ID (required to fetch items) */
   userId: string;
-  /** Error callback */
+  /** Error callback — receives the original Error */
   onError?: (error: Error) => void;
+  /** Override the default service (useful for tests) */
+  service?: ICalendarService;
 }
 
-interface UseCalendarReturn {
-  // Data
+export interface UseCalendarReturn {
   items: ContentItem[];
   loading: boolean;
   error: string | null;
@@ -28,182 +39,171 @@ interface UseCalendarReturn {
   selectedDate: Date;
   filter: CalendarFilter;
 
-  // Actions
   setCurrentView: (view: CalendarView) => void;
   setCurrentDate: (date: Date) => void;
   setSelectedDate: (date: Date) => void;
   setFilter: (filter: Partial<CalendarFilter>) => void;
   refresh: () => Promise<void>;
 
-  // CRUD
-  createItem: (item: Omit<ContentItem, 'id' | 'created_at' | 'updated_at'>) => Promise<ContentItem>;
+  createItem: (
+    item: Omit<ContentItem, 'id' | 'created_at' | 'updated_at'>,
+  ) => Promise<ContentItem>;
   updateItem: (id: string, updates: Partial<ContentItem>) => Promise<void>;
   deleteItem: (id: string) => Promise<void>;
   moveItem: (id: string, newDate: Date) => Promise<void>;
 
-  // Computed
   filteredItems: ContentItem[];
   itemsForDate: (date: Date) => ContentItem[];
 }
 
-type CalendarView = 'month' | 'week' | 'day' | 'timeline';
+const toError = (err: unknown, fallback: string): Error =>
+  err instanceof Error ? err : new Error(fallback);
 
-/**
- * useCalendar hook
- *
- * Manages calendar state and operations with config support
- */
 export function useCalendar(options: UseCalendarOptions): UseCalendarReturn {
-  const { config: userConfig, userId, onError } = options;
+  const { config: userConfig, userId, onError, service = calendarService } = options;
 
-  // Merge config with defaults
-  const config = useMemo(() => ({
-    ...DEFAULT_CALENDAR_CONFIG,
-    ...userConfig,
-  }), [userConfig]);
+  const config = useMemo(
+    () => ({ ...DEFAULT_CALENDAR_CONFIG, ...userConfig }),
+    [userConfig],
+  );
 
-  // State
   const [items, setItems] = useState<ContentItem[]>([]);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
-  const [currentView, setCurrentView] = useState<CalendarView>(config.defaultView || 'month');
-  const [currentDate, setCurrentDate] = useState(new Date());
-  const [selectedDate, setSelectedDate] = useState(new Date());
-  const [filter, setFilter] = useState<CalendarFilter>({});
+  const [currentView, setCurrentView] = useState<CalendarView>(
+    config.defaultView ?? 'month',
+  );
+  const [currentDate, setCurrentDate] = useState(() => new Date());
+  const [selectedDate, setSelectedDate] = useState(() => new Date());
+  const [filter, setFilterState] = useState<CalendarFilter>({});
+
+  // Keep the latest onError in a ref so refresh identity stays stable
+  // when consumers pass a fresh closure each render.
+  const onErrorRef = useRef(onError);
+  useEffect(() => {
+    onErrorRef.current = onError;
+  }, [onError]);
+
+  // Guards against out-of-order responses: only the most recent
+  // refresh may commit state (e.g. user changes the filter while a
+  // previous fetch is still resolving).
+  const requestIdRef = useRef(0);
 
-  // Fetch items
   const refresh = useCallback(async () => {
-    if (!userId) return;
+    if (!userId) {
+      setError('User ID is required to load calendar items');
+      return;
+    }
 
+    const requestId = ++requestIdRef.current;
     setLoading(true);
     setError(null);
-
     try {
-      const data = await calendarService.getContentItems(userId, filter);
-      setItems(data);
+      const data = await service.getContentItems(userId, filter);
+      if (requestIdRef.current === requestId) {
+        setItems(data);
+      }
     } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : 'Failed to fetch calendar items';
-      setError(errorMessage);
-      onError?.(err as Error);
+      if (requestIdRef.current === requestId) {
+        const wrapped = toError(err, 'Failed to fetch calendar items');
+        setError(wrapped.message);
+        onErrorRef.current?.(wrapped);
+      }
     } finally {
-      setLoading(false);
-    }
-  }, [userId, filter, onError]);
-
-  // Create item
-  const createItem = useCallback(async (item: Omit<ContentItem, 'id' | 'created_at' | 'updated_at'>): Promise<ContentItem> => {
-    if (!userId) {
-      throw new Error('User ID is required');
-    }
-
-    try {
-      const created = await calendarService.createContentItem(userId, item);
-      await refresh();
-      return created;
-    } catch (err) {
-      onError?.(err as Error);
-      throw err;
-    }
-  }, [userId, refresh, onError]);
-
-  // Update item
-  const updateItem = useCallback(async (id: string, updates: Partial<ContentItem>): Promise<void> => {
-    try {
-      await calendarService.updateContentItem(id, updates);
-      await refresh();
-    } catch (err) {
-      onError?.(err as Error);
-      throw err;
-    }
-  }, [refresh, onError]);
-
-  // Delete item
-  const deleteItem = useCallback(async (id: string): Promise<void> => {
-    try {
-      await calendarService.deleteContentItem(id);
-      await refresh();
-    } catch (err) {
-      onError?.(err as Error);
-      throw err;
-    }
-  }, [refresh, onError]);
-
-  // Move item
-  const moveItem = useCallback(async (id: string, newDate: Date): Promise<void> => {
-    try {
-      await calendarService.moveContentItem(id, newDate);
-      await refresh();
-    } catch (err) {
-      onError?.(err as Error);
-      throw err;
+      if (requestIdRef.current === requestId) {
+        setLoading(false);
+      }
     }
-  }, [refresh, onError]);
-
-  // Filter update
-  const updateFilter = useCallback((updates: Partial<CalendarFilter>) => {
-    setFilter(prev => ({ ...prev, ...updates }));
-  }, []);
-
-  // Get filtered items
-  const filteredItems = useMemo(() => {
-    return items.filter(item => {
-      // Search filter
-      if (filter.search && !item.title.toLowerCase().includes(filter.search.toLowerCase())) {
-        return false;
+  }, [userId, filter, service]);
+
+  const createItem = useCallback(
+    async (item: Omit<ContentItem, 'id' | 'created_at' | 'updated_at'>) => {
+      if (!userId) throw new Error('User ID is required');
+      try {
+        const created = await service.createContentItem(userId, item);
+        await refresh();
+        return created;
+      } catch (err) {
+        const wrapped = toError(err, 'Failed to create item');
+        onErrorRef.current?.(wrapped);
+        throw wrapped;
       }
-
-      // Platform filter
-      if (filter.platforms && filter.platforms.length > 0) {
-        if (!item.platforms.some(p => filter.platforms?.includes(p))) {
-          return false;
-        }
+    },
+    [userId, service, refresh],
+  );
+
+  const updateItem = useCallback(
+    async (id: string, updates: Partial<ContentItem>) => {
+      try {
+        await service.updateContentItem(id, updates);
+        await refresh();
+      } catch (err) {
+        const wrapped = toError(err, 'Failed to update item');
+        onErrorRef.current?.(wrapped);
+        throw wrapped;
       }
-
-      // Type filter
-      if (filter.types && filter.types.length > 0) {
-        if (!item.type || !filter.types.includes(item.type)) {
-          return false;
-        }
+    },
+    [service, refresh],
+  );
+
+  const deleteItem = useCallback(
+    async (id: string) => {
+      try {
+        await service.deleteContentItem(id);
+        await refresh();
+      } catch (err) {
+        const wrapped = toError(err, 'Failed to delete item');
+        onErrorRef.current?.(wrapped);
+        throw wrapped;
       }
-
-      // Status filter
-      if (filter.status && item.status !== filter.status) {
-        return false;
-      }
-
-      // Date range filter
-      if (filter.dateRange) {
-        const itemDate = new Date(item.scheduled_at);
-        if (itemDate < filter.dateRange.start || itemDate > filter.dateRange.end) {
-          return false;
-        }
+    },
+    [service, refresh],
+  );
+
+  const moveItem = useCallback(
+    async (id: string, newDate: Date) => {
+      try {
+        await service.moveContentItem(id, newDate);
+        await refresh();
+      } catch (err) {
+        const wrapped = toError(err, 'Failed to move item');
+        onErrorRef.current?.(wrapped);
+        throw wrapped;
       }
+    },
+    [service, refresh],
+  );
 
-      return true;
-    });
-  }, [items, filter]);
-
-  // Get items for specific date
-  const itemsForDate = useCallback((date: Date): ContentItem[] => {
-    const dateStart = new Date(date);
-    dateStart.setHours(0, 0, 0, 0);
-
-    const dateEnd = new Date(date);
-    dateEnd.setHours(23, 59, 59, 999);
+  const updateFilter = useCallback((updates: Partial<CalendarFilter>) => {
+    setFilterState((prev) => ({ ...prev, ...updates }));
+  }, []);
 
-    return filteredItems.filter(item => {
-      const itemDate = new Date(item.scheduled_at);
-      return itemDate >= dateStart && itemDate <= dateEnd;
-    });
-  }, [filteredItems]);
+  // Single source of truth for filtering (shared with the service layer)
+  // so client-side refiltering can never drift from server-side semantics.
+  const filteredItems = useMemo(
+    () => applyCalendarFilter(items, filter),
+    [items, filter],
+  );
+
+  const itemsForDate = useCallback(
+    (date: Date): ContentItem[] => {
+      const dateStart = new Date(date);
+      dateStart.setHours(0, 0, 0, 0);
+      const dateEnd = new Date(date);
+      dateEnd.setHours(23, 59, 59, 999);
+      return filteredItems.filter((item) => {
+        const itemDate = new Date(item.scheduled_at);
+        return itemDate >= dateStart && itemDate <= dateEnd;
+      });
+    },
+    [filteredItems],
+  );
 
-  // Initial fetch
   useEffect(() => {
     refresh();
   }, [refresh]);
 
   return {
-    // Data
     items,
     loading,
     error,
@@ -211,21 +211,15 @@ export function useCalendar(options: UseCalendarOptions): UseCalendarReturn {
     currentDate,
     selectedDate,
     filter,
-
-    // Actions
     setCurrentView,
     setCurrentDate,
     setSelectedDate,
     setFilter: updateFilter,
     refresh,
-
-    // CRUD
     createItem,
     updateItem,
     deleteItem,
     moveItem,
-
-    // Computed
     filteredItems,
     itemsForDate,
   };

package/src/domains/calendar/index.ts

@@ -6,4 +6,3 @@ export * from './types/calendar.types';
 export * from './services';
 export * from './hooks';
 export * from './utils';
-export * from './components';