@umituz/web-dashboard 3.2.2 → 4.0.0

package/src/domains/calendar/services/CalendarService.ts

@@ -1,7 +1,11 @@
 /**
  * Calendar Service
  *
- * Firebase-based calendar service for managing content items
+ * Camp-agnostic calendar service for managing content items.
+ * Persistence is injected via the `ICalendarDatabase` seam — the
+ * package ships no Firebase (or any other) backend. Use
+ * `createInMemoryCalendarDatabase()` for demos and tests, or adapt
+ * your own backend to the interface.
  */
 
 import type {
@@ -16,7 +20,7 @@ import type {
  * Database interface for calendar operations
  * Implementations can provide different backends
  */
-interface ICalendarDatabase {
+export interface ICalendarDatabase {
   getItems(userId: string): Promise<ContentItem[]>;
   getItemById(id: string): Promise<ContentItem | null>;
   createItem(userId: string, item: CreateContentItemParams): Promise<ContentItem>;
@@ -25,125 +29,120 @@ interface ICalendarDatabase {
 }
 
 /**
- * Firebase implementation of calendar database
+ * Resolve scheduled_at to ISO string regardless of source type
  */
-class FirebaseCalendarDatabase implements ICalendarDatabase {
-  async getItems(userId: string): Promise<ContentItem[]> {
-    // Lazy load Firebase
-    const { collection, query, where, getDocs } = await import('firebase/firestore');
-    const { getFirebaseDB } = await import('@umituz/web-firebase');
-    const db = getFirebaseDB();
-
-    const calendarQuery = query(
-      collection(db as any, 'calendar_items'),
-      where("user_id", "==", userId)
-    );
-
-    const postsQuery = query(
-      collection(db as any, "posts"),
-      where("userId", "==", userId)
-    );
-
-    const [calendarSnap, postsSnap] = await Promise.all([
-      getDocs(calendarQuery),
-      getDocs(postsQuery)
-    ]);
-
-    const calendarItems = calendarSnap.docs.map((doc: { id: string; data: () => Record<string, unknown> }) => ({
-      id: doc.id,
-      ...doc.data()
-    } as ContentItem));
-
-    const postItems = postsSnap.docs.map((doc: { id: string; data: () => Record<string, unknown> }) => {
-      const data = doc.data();
-      return {
-        id: doc.id,
-        title: data.title || 'Untitled Post',
-        description: data.content || '',
-        scheduled_at: data.scheduledAt
-          ? (typeof data.scheduledAt === 'string' ? data.scheduledAt : (data.scheduledAt as { toDate: () => Date })?.toDate?.().toISOString())
-          : new Date().toISOString(),
-        platforms: data.platform ? [data.platform] : [],
-        app_name: data.appName || 'My App',
-        status: data.status || 'draft',
-        type: 'post'
-      } as ContentItem;
-    });
-
-    return [...calendarItems, ...postItems].sort((a, b) =>
-      new Date(b.scheduled_at).getTime() - new Date(a.scheduled_at).getTime()
-    );
+const resolveScheduledAt = (value: string | Date | undefined): string => {
+  if (value === undefined) {
+    throw new Error('scheduled_at is required to create or update a content item');
   }
+  if (typeof value === 'string') return value;
+  return value.toISOString();
+};
 
-  async getItemById(id: string): Promise<ContentItem | null> {
-    const { doc, getDoc } = await import('firebase/firestore');
-    const { getFirebaseDB } = await import('@umituz/web-firebase');
-    const db = getFirebaseDB();
-
-    const docRef = doc(db as any, 'calendar_items', id);
-    const snap = await getDoc(docRef);
+/**
+ * In-memory calendar database — zero-dependency default for demos
+ * and tests. Data lives per-instance for the lifetime of the page.
+ */
+export const createInMemoryCalendarDatabase = (): ICalendarDatabase => {
+  const items = new Map<string, ContentItem>();
+
+  const findByUser = (userId: string): ContentItem[] =>
+    [...items.values()].filter((item) => item.user_id === userId);
+
+  return {
+    async getItems(userId: string): Promise<ContentItem[]> {
+      return findByUser(userId).sort(
+        (a, b) =>
+          new Date(b.scheduled_at).getTime() - new Date(a.scheduled_at).getTime(),
+      );
+    },
+
+    async getItemById(id: string): Promise<ContentItem | null> {
+      return items.get(id) ?? null;
+    },
+
+    async createItem(
+      userId: string,
+      item: CreateContentItemParams,
+    ): Promise<ContentItem> {
+      const created: ContentItem = {
+        id: `item-${items.size + 1}-${userId}`,
+        title: item.title ?? '',
+        description: item.description ?? '',
+        scheduled_at: resolveScheduledAt(item.scheduled_at),
+        platforms: item.platforms ?? [],
+        app_name: item.app_name ?? '',
+        status: item.status ?? 'draft',
+        type: item.type ?? 'post',
+        user_id: userId,
+        created_at: new Date().toISOString(),
+      };
+      items.set(created.id, created);
+      return created;
+    },
+
+    async updateItem(id: string, updates: UpdateContentItemParams): Promise<void> {
+      const current = items.get(id);
+      if (!current) {
+        throw new Error(`Calendar item not found: ${id}`);
+      }
+      items.set(id, {
+        ...current,
+        ...updates,
+        scheduled_at:
+          updates.scheduled_at !== undefined
+            ? resolveScheduledAt(updates.scheduled_at)
+            : current.scheduled_at,
+      });
+    },
+
+    async deleteItem(id: string): Promise<void> {
+      items.delete(id);
+    },
+  };
+};
 
-    if (!snap.exists()) {
-      return null;
+/**
+ * Apply a CalendarFilter to a list of items.
+ * Single source of truth for filtering, shared between hook and service.
+ */
+const applyCalendarFilter = (items: ContentItem[], filter?: CalendarFilter): ContentItem[] => {
+  if (!filter) return items;
+
+  return items.filter((item) => {
+    if (filter.search) {
+      const title = item.title?.toLowerCase() ?? '';
+      const query = filter.search.toLowerCase();
+      if (!title.includes(query)) return false;
     }
 
-    return {
-      id: snap.id,
-      ...snap.data()
-    } as ContentItem;
-  }
-
-  async createItem(userId: string, item: CreateContentItemParams): Promise<ContentItem> {
-    const { collection, addDoc, serverTimestamp } = await import('firebase/firestore');
-    const { getFirebaseDB } = await import('@umituz/web-firebase');
-    const db = getFirebaseDB();
-
-    const docRef = await addDoc(collection(db as any, 'calendar_items'), {
-      ...item,
-      scheduled_at: typeof item.scheduled_at === 'string' ? item.scheduled_at : item.scheduled_at.toISOString(),
-      user_id: userId,
-      created_at: serverTimestamp(),
-      updated_at: serverTimestamp()
-    });
-
-    return {
-      id: docRef.id,
-      ...item,
-      scheduled_at: typeof item.scheduled_at === 'string' ? item.scheduled_at : item.scheduled_at.toISOString(),
-      user_id: userId,
-      created_at: new Date().toISOString()
-    } as ContentItem;
-  }
-
-  async updateItem(id: string, updates: UpdateContentItemParams): Promise<void> {
-    const { doc, updateDoc, serverTimestamp } = await import('firebase/firestore');
-    const { getFirebaseDB } = await import('@umituz/web-firebase');
-    const db = getFirebaseDB();
-
-    const docRef = doc(db as any, 'calendar_items', id);
+    if (filter.platforms && filter.platforms.length > 0) {
+      const itemPlatforms = item.platforms ?? [];
+      if (!itemPlatforms.some((p) => filter.platforms?.includes(p))) {
+        return false;
+      }
+    }
 
-    const updateData: Record<string, unknown> = { ...updates };
-    if (updates.scheduled_at) {
-      updateData.scheduled_at = typeof updates.scheduled_at === 'string'
-        ? updates.scheduled_at
-        : updates.scheduled_at.toISOString();
+    if (filter.types && filter.types.length > 0) {
+      if (!item.type || !filter.types.includes(item.type)) {
+        return false;
+      }
     }
 
-    await updateDoc(docRef, {
-      ...updateData,
-      updated_at: serverTimestamp()
-    });
-  }
+    if (filter.status && item.status !== filter.status) {
+      return false;
+    }
 
-  async deleteItem(id: string): Promise<void> {
-    const { doc, deleteDoc } = await import('firebase/firestore');
-    const { getFirebaseDB } = await import('@umituz/web-firebase');
-    const db = getFirebaseDB();
+    if (filter.dateRange) {
+      const itemDate = new Date(item.scheduled_at);
+      if (itemDate < filter.dateRange.start || itemDate > filter.dateRange.end) {
+        return false;
+      }
+    }
 
-    const docRef = doc(db as any, 'calendar_items', id);
-    await deleteDoc(docRef);
-  }
-}
+    return true;
+  });
+};
 
 /**
  * Calendar Service Implementation
@@ -152,19 +151,10 @@ class FirebaseCalendarDatabase implements ICalendarDatabase {
  * Uses database interface for backend abstraction
  */
 export class CalendarService implements ICalendarService {
-  private static instance: CalendarService;
   private database: ICalendarDatabase;
 
-  private constructor() {
-    // Use Firebase implementation by default
-    this.database = new FirebaseCalendarDatabase();
-  }
-
-  public static getInstance(): CalendarService {
-    if (!CalendarService.instance) {
-      CalendarService.instance = new CalendarService();
-    }
-    return CalendarService.instance;
+  constructor(database: ICalendarDatabase = createInMemoryCalendarDatabase()) {
+    this.database = database;
   }
 
   /**
@@ -175,90 +165,43 @@ export class CalendarService implements ICalendarService {
   }
 
   /**
-   * Get all content items for a user
+   * Get all content items for a user, with optional filter
    */
   async getContentItems(userId: string, filter?: CalendarFilter): Promise<ContentItem[]> {
     const items = await this.database.getItems(userId);
-
-    if (!filter) return items;
-
-    // Apply filters
-    return items.filter(item => {
-      // Search filter
-      if (filter.search && !item.title.toLowerCase().includes(filter.search.toLowerCase())) {
-        return false;
-      }
-
-      // Platform filter
-      if (filter.platforms && filter.platforms.length > 0) {
-        if (!item.platforms.some(p => filter.platforms?.includes(p))) {
-          return false;
-        }
-      }
-
-      // Type filter
-      if (filter.types && filter.types.length > 0) {
-        if (!item.type || !filter.types.includes(item.type)) {
-          return false;
-        }
-      }
-
-      // 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;
-        }
-      }
-
-      return true;
-    });
+    return applyCalendarFilter(items, filter);
   }
 
-  /**
-   * Get a single content item by ID
-   */
   async getContentItemById(id: string): Promise<ContentItem | null> {
     return this.database.getItemById(id);
   }
 
-  /**
-   * Create a new content item
-   */
   async createContentItem(userId: string, item: CreateContentItemParams): Promise<ContentItem> {
     return this.database.createItem(userId, item);
   }
 
-  /**
-   * Update an existing content item
-   */
   async updateContentItem(id: string, updates: UpdateContentItemParams): Promise<void> {
     await this.database.updateItem(id, updates);
   }
 
-  /**
-   * Delete a content item
-   */
   async deleteContentItem(id: string): Promise<void> {
     await this.database.deleteItem(id);
   }
 
-  /**
-   * Move content item to a new date
-   */
   async moveContentItem(id: string, newDate: Date): Promise<void> {
     await this.updateContentItem(id, {
-      scheduled_at: newDate
+      scheduled_at: newDate,
     });
   }
 }
 
 /**
- * Singleton instance
+ * Default singleton instance (in-memory — swap the backend via
+ * `setDatabase` or construct your own `CalendarService`).
+ */
+export const calendarService = new CalendarService();
+
+/**
+ * Exported for testing/extension.
  */
-export const calendarService = CalendarService.getInstance();
+export { applyCalendarFilter };

package/src/domains/calendar/utils/contentItemMapper.test.ts

@@ -0,0 +1,108 @@
+/**
+ * Tests for the calendar Firestore → ContentItem mappers.
+ */
+
+import { describe, it, expect } from "vitest";
+import { mapCalendarDocument, mapPostDocument } from "./contentItemMapper";
+import type { FirestoreDocument } from "./contentItemMapper";
+
+const makeDoc = (data: Record<string, unknown>): FirestoreDocument => ({
+  id: "doc-1",
+  data: () => data as never,
+});
+
+describe("mapCalendarDocument", () => {
+  it("maps a fully populated document", () => {
+    const item = mapCalendarDocument(
+      makeDoc({
+        title: "Launch post",
+        description: "Hello world",
+        scheduled_at: "2026-09-01T10:00:00.000Z",
+        platforms: ["twitter", "linkedin"],
+        app_name: "MyApp",
+        status: "scheduled",
+        type: "post",
+      }),
+    );
+
+    expect(item).toEqual({
+      id: "doc-1",
+      title: "Launch post",
+      description: "Hello world",
+      scheduled_at: "2026-09-01T10:00:00.000Z",
+      platforms: ["twitter", "linkedin"],
+      app_name: "MyApp",
+      status: "scheduled",
+      type: "post",
+    });
+  });
+
+  it("falls back to empty strings, never to package-side copy", () => {
+    const item = mapCalendarDocument(makeDoc({}));
+
+    expect(item.title).toBe("");
+    expect(item.description).toBe("");
+    expect(item.app_name).toBe("");
+    expect(item.platforms).toEqual([]);
+  });
+
+  it("normalizes unknown status/type to draft/post", () => {
+    const item = mapCalendarDocument(
+      makeDoc({ status: "weird", type: "unsupported" }),
+    );
+    expect(item.status).toBe("draft");
+    expect(item.type).toBe("post");
+  });
+
+  it("converts Firestore timestamps via toDate()", () => {
+    const item = mapCalendarDocument(
+      makeDoc({
+        scheduled_at: { toDate: () => new Date("2026-09-01T00:00:00.000Z") },
+      }),
+    );
+    expect(item.scheduled_at).toBe("2026-09-01T00:00:00.000Z");
+  });
+
+  it("maps a missing scheduled_at to the epoch, not 'now'", () => {
+    const item = mapCalendarDocument(makeDoc({}));
+    expect(item.scheduled_at).toBe(new Date(0).toISOString());
+  });
+
+  it("prefers camelCase appName as fallback", () => {
+    const item = mapCalendarDocument(makeDoc({ appName: "CamelApp" }));
+    expect(item.app_name).toBe("CamelApp");
+  });
+});
+
+describe("mapPostDocument", () => {
+  it("maps a posts-collection document", () => {
+    const item = mapPostDocument(
+      makeDoc({
+        title: "Post title",
+        content: "Body text",
+        scheduledAt: "2026-10-01T08:00:00.000Z",
+        platform: "instagram",
+        appName: "MyApp",
+        status: "published",
+      }),
+    );
+
+    expect(item).toEqual({
+      id: "doc-1",
+      title: "Post title",
+      description: "Body text",
+      scheduled_at: "2026-10-01T08:00:00.000Z",
+      platforms: ["instagram"],
+      app_name: "MyApp",
+      status: "published",
+      type: "post",
+    });
+  });
+
+  it("falls back to empty strings for missing display fields", () => {
+    const item = mapPostDocument(makeDoc({}));
+    expect(item.title).toBe("");
+    expect(item.description).toBe("");
+    expect(item.platforms).toEqual([]);
+  });
+});

package/src/domains/calendar/utils/contentItemMapper.ts

@@ -0,0 +1,99 @@
+/**
+ * Content Item Mapper
+ *
+ * Type-safe transformation between wire-format documents and domain ContentItem objects.
+ */
+
+import type { ContentItem, ContentStatus, ContentType } from '../types/calendar.types';
+
+/**
+ * Raw wire document shape for calendar_items records
+ */
+interface CalendarItemDocument {
+  title?: string;
+  description?: string;
+  scheduled_at?: string | { toDate: () => Date };
+  platforms?: string[];
+  app_name?: string;
+  status?: string;
+  type?: string;
+  content?: string;
+  platform?: string;
+  appName?: string;
+  scheduledAt?: string | { toDate: () => Date };
+  userId?: string;
+  user_id?: string;
+  created_at?: string | { toDate: () => Date };
+  updated_at?: string | { toDate: () => Date };
+}
+
+/**
+ * Firestore document with id
+ */
+export interface FirestoreDocument<T = Record<string, unknown>> {
+  id: string;
+  data: () => T;
+}
+
+/**
+ * Convert Firebase timestamp value to ISO string.
+ * A missing value maps to the epoch rather than "now" — missing data
+ * must not masquerade as freshly-scheduled content in date-sorted views.
+ */
+const toIsoString = (value: string | { toDate: () => Date } | undefined): string => {
+  if (!value) return new Date(0).toISOString();
+  if (typeof value === 'string') return value;
+  return value.toDate().toISOString();
+};
+
+/**
+ * Normalize status string to ContentStatus union
+ */
+const normalizeStatus = (status: string | undefined): ContentStatus => {
+  const valid: ContentStatus[] = ['draft', 'scheduled', 'published', 'failed'];
+  return valid.includes(status as ContentStatus) ? (status as ContentStatus) : 'draft';
+};
+
+/**
+ * Normalize type string to ContentType union
+ */
+const normalizeType = (type: string | undefined): ContentType => {
+  const valid: ContentType[] = ['post', 'story', 'reel', 'tweet', 'article'];
+  return valid.includes(type as ContentType) ? (type as ContentType) : 'post';
+};
+
+/**
+ * Map calendar_items document to ContentItem
+ */
+export const mapCalendarDocument = (doc: FirestoreDocument<CalendarItemDocument>): ContentItem => {
+  const data = doc.data();
+  return {
+    id: doc.id,
+    title: data.title ?? '',
+    description: data.description ?? data.content ?? '',
+    scheduled_at: toIsoString(data.scheduled_at),
+    platforms: Array.isArray(data.platforms) ? data.platforms : [],
+    app_name: data.app_name ?? data.appName ?? '',
+    status: normalizeStatus(data.status),
+    type: normalizeType(data.type),
+  };
+};
+
+/**
+ * Map posts document to ContentItem.
+ * Missing display fields fall back to empty strings so the consuming
+ * UI can render its own (localized) placeholder — no package-side copy.
+ */
+export const mapPostDocument = (doc: FirestoreDocument<CalendarItemDocument>): ContentItem => {
+  const data = doc.data();
+  return {
+    id: doc.id,
+    title: data.title ?? '',
+    description: data.content ?? '',
+    scheduled_at: toIsoString(data.scheduledAt),
+    platforms: data.platform ? [data.platform] : [],
+    app_name: data.appName ?? '',
+    status: normalizeStatus(data.status),
+    type: 'post',
+  };
+};

package/src/domains/calendar/utils/index.ts

@@ -4,36 +4,20 @@
 
 import type { CalendarConfig } from '../types/calendar.types';
 
-/**
- * Default calendar configuration
- */
-export const DEFAULT_CALENDAR_CONFIG: CalendarConfig = {
-  defaultView: 'month',
-  showWeekends: true,
-  startOfWeek: 0, // Sunday
-  hourRange: {
-    start: 0,
-    end: 23,
-  },
-  enableDragDrop: true,
-  showPlatformFilters: true,
-  platforms: ['instagram', 'facebook', 'twitter', 'linkedin', 'tiktok'],
-  slotDuration: 30, // 30 minutes
-};
+export { mapCalendarDocument, mapPostDocument } from './contentItemMapper';
+export type { FirestoreDocument } from './contentItemMapper';
 
 /**
  * Get week dates for a given date
  */
 export function getWeekDates(date: Date, startOfWeek: number = 0): Date[] {
-  const week = [];
+  const week: Date[] = [];
   const current = new Date(date);
 
-  // Find the first day of the week
   const day = current.getDay();
   const diff = (day < startOfWeek ? 7 : 0) + day - startOfWeek;
   current.setDate(current.getDate() - diff);
 
-  // Get 7 days
   for (let i = 0; i < 7; i++) {
     week.push(new Date(current));
     current.setDate(current.getDate() + 1);
@@ -68,17 +52,22 @@ export function isDateInRange(date: Date, range: { start: Date; end: Date }): bo
 }
 
 /**
- * Format date for display
+ * Format date for display.
+ * The locale is taken as a parameter so the consumer can decide.
  */
-export function formatDate(date: Date, format: 'short' | 'long' | 'time' = 'short'): string {
+export function formatDate(
+  date: Date,
+  format: 'short' | 'long' | 'time' = 'short',
+  locale: string = 'en-US',
+): string {
   if (format === 'time') {
-    return date.toLocaleTimeString('en-US', {
+    return date.toLocaleTimeString(locale, {
       hour: '2-digit',
       minute: '2-digit',
     });
   }
 
-  return date.toLocaleDateString('en-US', {
+  return date.toLocaleDateString(locale, {
     month: format === 'long' ? 'long' : 'short',
     day: 'numeric',
     year: 'numeric',
@@ -99,25 +88,32 @@ export function isSameDay(date1: Date, date2: Date): boolean {
 /**
  * Get date range for a view
  */
-export function getViewRange(view: 'month' | 'week', date: Date): { start: Date; end: Date } {
+export function getViewRange(
+  view: 'month' | 'week',
+  date: Date,
+): { start: Date; end: Date } {
   if (view === 'month') {
     const start = new Date(date.getFullYear(), date.getMonth(), 1);
     const end = new Date(date.getFullYear(), date.getMonth() + 1, 0);
     return { start, end };
   }
 
-  // Week view
   const week = getWeekDates(date);
-  return {
-    start: new Date(week[0].setHours(0, 0, 0, 0)),
-    end: new Date(week[6].setHours(23, 59, 59, 999)),
-  };
+  const firstDay = new Date(week[0]);
+  firstDay.setHours(0, 0, 0, 0);
+  const lastDay = new Date(week[6]);
+  lastDay.setHours(23, 59, 59, 999);
+  return { start: firstDay, end: lastDay };
 }
 
 /**
  * Generate time slots
  */
-export function generateTimeSlots(startHour: number, endHour: number, slotDuration: number): string[] {
+export function generateTimeSlots(
+  startHour: number,
+  endHour: number,
+  slotDuration: number,
+): string[] {
   const slots: string[] = [];
 
   for (let hour = startHour; hour < endHour; hour++) {
@@ -129,3 +125,10 @@ export function generateTimeSlots(startHour: number, endHour: number, slotDurati
 
   return slots;
 }
+
+/**
+ * Re-export the default calendar config from the central config module
+ * so consumers using only the calendar domain still get sensible defaults.
+ */
+export { DEFAULT_CALENDAR_CONFIG } from '../../../domain/config/CalendarConfig';
+export type { CalendarConfig };